Ruby  2.0.0p247(2013-06-27revision41674)
ext/zlib/zlib.c
Go to the documentation of this file.
00001 /*
00002  * zlib.c - An interface for zlib.
00003  *
00004  *   Copyright (C) UENO Katsuhiro 2000-2003
00005  *
00006  * $Id: zlib.c 41073 2013-06-04 15:44:57Z nagachika $
00007  */
00008 
00009 #include <ruby.h>
00010 #include <zlib.h>
00011 #include <time.h>
00012 #include <ruby/io.h>
00013 #include <ruby/thread.h>
00014 
00015 #ifdef HAVE_VALGRIND_MEMCHECK_H
00016 # include <valgrind/memcheck.h>
00017 # ifndef VALGRIND_MAKE_MEM_DEFINED
00018 #  define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
00019 # endif
00020 # ifndef VALGRIND_MAKE_MEM_UNDEFINED
00021 #  define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
00022 # endif
00023 #else
00024 # define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
00025 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
00026 #endif
00027 
00028 #define RUBY_ZLIB_VERSION  "0.6.0"
00029 
00030 
00031 #define OBJ_IS_FREED(val)  (RBASIC(val)->flags == 0)
00032 
00033 #ifndef GZIP_SUPPORT
00034 #define GZIP_SUPPORT  1
00035 #endif
00036 
00037 /* from zutil.h */
00038 #ifndef DEF_MEM_LEVEL
00039 #if MAX_MEM_LEVEL >= 8
00040 #define DEF_MEM_LEVEL  8
00041 #else
00042 #define DEF_MEM_LEVEL  MAX_MEM_LEVEL
00043 #endif
00044 #endif
00045 
00046 #if SIZEOF_LONG > SIZEOF_INT
00047 static inline uInt
00048 max_uint(long n)
00049 {
00050     if (n > UINT_MAX) n = UINT_MAX;
00051     return (uInt)n;
00052 }
00053 #define MAX_UINT(n) max_uint(n)
00054 #else
00055 #define MAX_UINT(n) (uInt)(n)
00056 #endif
00057 
00058 #define sizeof(x) ((int)sizeof(x))
00059 
00060 static ID id_dictionaries;
00061 
00062 /*--------- Prototypes --------*/
00063 
00064 static NORETURN(void raise_zlib_error(int, const char*));
00065 static VALUE rb_zlib_version(VALUE);
00066 static VALUE do_checksum(int, VALUE*, uLong (*)(uLong, const Bytef*, uInt));
00067 static VALUE rb_zlib_adler32(int, VALUE*, VALUE);
00068 static VALUE rb_zlib_crc32(int, VALUE*, VALUE);
00069 static VALUE rb_zlib_crc_table(VALUE);
00070 static voidpf zlib_mem_alloc(voidpf, uInt, uInt);
00071 static void zlib_mem_free(voidpf, voidpf);
00072 static void finalizer_warn(const char*);
00073 
00074 struct zstream;
00075 struct zstream_funcs;
00076 struct zstream_run_args;
00077 static void zstream_init(struct zstream*, const struct zstream_funcs*);
00078 static void zstream_expand_buffer(struct zstream*);
00079 static void zstream_expand_buffer_into(struct zstream*, unsigned long);
00080 static void zstream_append_buffer(struct zstream*, const Bytef*, long);
00081 static VALUE zstream_detach_buffer(struct zstream*);
00082 static VALUE zstream_shift_buffer(struct zstream*, long);
00083 static void zstream_buffer_ungets(struct zstream*, const Bytef*, unsigned long);
00084 static void zstream_buffer_ungetbyte(struct zstream*, int);
00085 static void zstream_append_input(struct zstream*, const Bytef*, long);
00086 static void zstream_discard_input(struct zstream*, long);
00087 static void zstream_reset_input(struct zstream*);
00088 static void zstream_passthrough_input(struct zstream*);
00089 static VALUE zstream_detach_input(struct zstream*);
00090 static void zstream_reset(struct zstream*);
00091 static VALUE zstream_end(struct zstream*);
00092 static void zstream_run(struct zstream*, Bytef*, long, int);
00093 static VALUE zstream_sync(struct zstream*, Bytef*, long);
00094 static void zstream_mark(struct zstream*);
00095 static void zstream_free(struct zstream*);
00096 static VALUE zstream_new(VALUE, const struct zstream_funcs*);
00097 static struct zstream *get_zstream(VALUE);
00098 static void zstream_finalize(struct zstream*);
00099 
00100 static VALUE rb_zstream_end(VALUE);
00101 static VALUE rb_zstream_reset(VALUE);
00102 static VALUE rb_zstream_finish(VALUE);
00103 static VALUE rb_zstream_flush_next_in(VALUE);
00104 static VALUE rb_zstream_flush_next_out(VALUE);
00105 static VALUE rb_zstream_avail_out(VALUE);
00106 static VALUE rb_zstream_set_avail_out(VALUE, VALUE);
00107 static VALUE rb_zstream_avail_in(VALUE);
00108 static VALUE rb_zstream_total_in(VALUE);
00109 static VALUE rb_zstream_total_out(VALUE);
00110 static VALUE rb_zstream_data_type(VALUE);
00111 static VALUE rb_zstream_adler(VALUE);
00112 static VALUE rb_zstream_finished_p(VALUE);
00113 static VALUE rb_zstream_closed_p(VALUE);
00114 
00115 static VALUE rb_deflate_s_allocate(VALUE);
00116 static VALUE rb_deflate_initialize(int, VALUE*, VALUE);
00117 static VALUE rb_deflate_init_copy(VALUE, VALUE);
00118 static VALUE deflate_run(VALUE);
00119 static VALUE rb_deflate_s_deflate(int, VALUE*, VALUE);
00120 static void do_deflate(struct zstream*, VALUE, int);
00121 static VALUE rb_deflate_deflate(int, VALUE*, VALUE);
00122 static VALUE rb_deflate_addstr(VALUE, VALUE);
00123 static VALUE rb_deflate_flush(int, VALUE*, VALUE);
00124 static VALUE rb_deflate_params(VALUE, VALUE, VALUE);
00125 static VALUE rb_deflate_set_dictionary(VALUE, VALUE);
00126 
00127 static VALUE inflate_run(VALUE);
00128 static VALUE rb_inflate_s_allocate(VALUE);
00129 static VALUE rb_inflate_initialize(int, VALUE*, VALUE);
00130 static VALUE rb_inflate_s_inflate(VALUE, VALUE);
00131 static void do_inflate(struct zstream*, VALUE);
00132 static VALUE rb_inflate_inflate(VALUE, VALUE);
00133 static VALUE rb_inflate_addstr(VALUE, VALUE);
00134 static VALUE rb_inflate_sync(VALUE, VALUE);
00135 static VALUE rb_inflate_sync_point_p(VALUE);
00136 static VALUE rb_inflate_set_dictionary(VALUE, VALUE);
00137 
00138 #if GZIP_SUPPORT
00139 struct gzfile;
00140 static void gzfile_mark(struct gzfile*);
00141 static void gzfile_free(struct gzfile*);
00142 static VALUE gzfile_new(VALUE, const struct zstream_funcs*, void (*) _((struct gzfile*)));
00143 static void gzfile_reset(struct gzfile*);
00144 static void gzfile_close(struct gzfile*, int);
00145 static void gzfile_write_raw(struct gzfile*);
00146 static VALUE gzfile_read_raw_partial(VALUE);
00147 static VALUE gzfile_read_raw_rescue(VALUE);
00148 static VALUE gzfile_read_raw(struct gzfile*);
00149 static int gzfile_read_raw_ensure(struct gzfile*, long);
00150 static char *gzfile_read_raw_until_zero(struct gzfile*, long);
00151 static unsigned int gzfile_get16(const unsigned char*);
00152 static unsigned long gzfile_get32(const unsigned char*);
00153 static void gzfile_set32(unsigned long n, unsigned char*);
00154 static void gzfile_make_header(struct gzfile*);
00155 static void gzfile_make_footer(struct gzfile*);
00156 static void gzfile_read_header(struct gzfile*);
00157 static void gzfile_check_footer(struct gzfile*);
00158 static void gzfile_write(struct gzfile*, Bytef*, long);
00159 static long gzfile_read_more(struct gzfile*);
00160 static void gzfile_calc_crc(struct gzfile*, VALUE);
00161 static VALUE gzfile_read(struct gzfile*, long);
00162 static VALUE gzfile_read_all(struct gzfile*);
00163 static void gzfile_ungets(struct gzfile*, const Bytef*, long);
00164 static void gzfile_ungetbyte(struct gzfile*, int);
00165 static VALUE gzfile_writer_end_run(VALUE);
00166 static void gzfile_writer_end(struct gzfile*);
00167 static VALUE gzfile_reader_end_run(VALUE);
00168 static void gzfile_reader_end(struct gzfile*);
00169 static void gzfile_reader_rewind(struct gzfile*);
00170 static VALUE gzfile_reader_get_unused(struct gzfile*);
00171 static struct gzfile *get_gzfile(VALUE);
00172 static VALUE gzfile_ensure_close(VALUE);
00173 static VALUE rb_gzfile_s_wrap(int, VALUE*, VALUE);
00174 static VALUE gzfile_s_open(int, VALUE*, VALUE, const char*);
00175 NORETURN(static void gzfile_raise(struct gzfile *, VALUE, const char *));
00176 static VALUE gzfile_error_inspect(VALUE);
00177 
00178 static VALUE rb_gzfile_to_io(VALUE);
00179 static VALUE rb_gzfile_crc(VALUE);
00180 static VALUE rb_gzfile_mtime(VALUE);
00181 static VALUE rb_gzfile_level(VALUE);
00182 static VALUE rb_gzfile_os_code(VALUE);
00183 static VALUE rb_gzfile_orig_name(VALUE);
00184 static VALUE rb_gzfile_comment(VALUE);
00185 static VALUE rb_gzfile_lineno(VALUE);
00186 static VALUE rb_gzfile_set_lineno(VALUE, VALUE);
00187 static VALUE rb_gzfile_set_mtime(VALUE, VALUE);
00188 static VALUE rb_gzfile_set_orig_name(VALUE, VALUE);
00189 static VALUE rb_gzfile_set_comment(VALUE, VALUE);
00190 static VALUE rb_gzfile_close(VALUE);
00191 static VALUE rb_gzfile_finish(VALUE);
00192 static VALUE rb_gzfile_closed_p(VALUE);
00193 static VALUE rb_gzfile_eof_p(VALUE);
00194 static VALUE rb_gzfile_sync(VALUE);
00195 static VALUE rb_gzfile_set_sync(VALUE, VALUE);
00196 static VALUE rb_gzfile_total_in(VALUE);
00197 static VALUE rb_gzfile_total_out(VALUE);
00198 static VALUE rb_gzfile_path(VALUE);
00199 
00200 static VALUE rb_gzwriter_s_allocate(VALUE);
00201 static VALUE rb_gzwriter_s_open(int, VALUE*, VALUE);
00202 static VALUE rb_gzwriter_initialize(int, VALUE*, VALUE);
00203 static VALUE rb_gzwriter_flush(int, VALUE*, VALUE);
00204 static VALUE rb_gzwriter_write(VALUE, VALUE);
00205 static VALUE rb_gzwriter_putc(VALUE, VALUE);
00206 
00207 static VALUE rb_gzreader_s_allocate(VALUE);
00208 static VALUE rb_gzreader_s_open(int, VALUE*, VALUE);
00209 static VALUE rb_gzreader_initialize(int, VALUE*, VALUE);
00210 static VALUE rb_gzreader_rewind(VALUE);
00211 static VALUE rb_gzreader_unused(VALUE);
00212 static VALUE rb_gzreader_read(int, VALUE*, VALUE);
00213 static VALUE rb_gzreader_getc(VALUE);
00214 static VALUE rb_gzreader_readchar(VALUE);
00215 static VALUE rb_gzreader_each_byte(VALUE);
00216 static VALUE rb_gzreader_ungetc(VALUE, VALUE);
00217 static VALUE rb_gzreader_ungetbyte(VALUE, VALUE);
00218 static void gzreader_skip_linebreaks(struct gzfile*);
00219 static VALUE gzreader_gets(int, VALUE*, VALUE);
00220 static VALUE rb_gzreader_gets(int, VALUE*, VALUE);
00221 static VALUE rb_gzreader_readline(int, VALUE*, VALUE);
00222 static VALUE rb_gzreader_each(int, VALUE*, VALUE);
00223 static VALUE rb_gzreader_readlines(int, VALUE*, VALUE);
00224 #endif /* GZIP_SUPPORT */
00225 
00226 /*
00227  * Document-module: Zlib
00228  *
00229  * This module provides access to the {zlib library}[http://zlib.net]. Zlib is
00230  * designed to be a portable, free, general-purpose, legally unencumbered --
00231  * that is, not covered by any patents -- lossless data-compression library
00232  * for use on virtually any computer hardware and operating system.
00233  *
00234  * The zlib compression library provides in-memory compression and
00235  * decompression functions, including integrity checks of the uncompressed
00236  * data.
00237  *
00238  * The zlib compressed data format is described in RFC 1950, which is a
00239  * wrapper around a deflate stream which is described in RFC 1951.
00240  *
00241  * The library also supports reading and writing files in gzip (.gz) format
00242  * with an interface similar to that of IO. The gzip format is described in
00243  * RFC 1952 which is also a wrapper around a deflate stream.
00244  *
00245  * The zlib format was designed to be compact and fast for use in memory and on
00246  * communications channels. The gzip format was designed for single-file
00247  * compression on file systems, has a larger header than zlib to maintain
00248  * directory information, and uses a different, slower check method than zlib.
00249  *
00250  * See your system's zlib.h for further information about zlib
00251  *
00252  * == Sample usage
00253  *
00254  * Using the wrapper to compress strings with default parameters is quite
00255  * simple:
00256  *
00257  *   require "zlib"
00258  *
00259  *   data_to_compress = File.read("don_quixote.txt")
00260  *
00261  *   puts "Input size: #{data_to_compress.size}"
00262  *   #=> Input size: 2347740
00263  *
00264  *   data_compressed = Zlib::Deflate.deflate(data_to_compress)
00265  *
00266  *   puts "Compressed size: #{data_compressed.size}"
00267  *   #=> Compressed size: 887238
00268  *
00269  *   uncompressed_data = Zlib::Inflate.inflate(data_compressed)
00270  *
00271  *   puts "Uncompressed data is: #{uncompressed_data}"
00272  *   #=> Uncompressed data is: The Project Gutenberg EBook of Don Quixote...
00273  *
00274  * == Class tree
00275  *
00276  * - Zlib::Deflate
00277  * - Zlib::Inflate
00278  * - Zlib::ZStream
00279  * - Zlib::Error
00280  *   - Zlib::StreamEnd
00281  *   - Zlib::NeedDict
00282  *   - Zlib::DataError
00283  *   - Zlib::StreamError
00284  *   - Zlib::MemError
00285  *   - Zlib::BufError
00286  *   - Zlib::VersionError
00287  *
00288  * (if you have GZIP_SUPPORT)
00289  * - Zlib::GzipReader
00290  * - Zlib::GzipWriter
00291  * - Zlib::GzipFile
00292  * - Zlib::GzipFile::Error
00293  *   - Zlib::GzipFile::LengthError
00294  *   - Zlib::GzipFile::CRCError
00295  *   - Zlib::GzipFile::NoFooter
00296  *
00297  */
00298 void Init_zlib(void);
00299 
00300 /*--------- Exceptions --------*/
00301 
00302 static VALUE cZError, cStreamEnd, cNeedDict;
00303 static VALUE cStreamError, cDataError, cMemError, cBufError, cVersionError;
00304 
00305 static void
00306 raise_zlib_error(int err, const char *msg)
00307 {
00308     VALUE exc;
00309 
00310     if (!msg) {
00311         msg = zError(err);
00312     }
00313 
00314     switch(err) {
00315       case Z_STREAM_END:
00316         exc = rb_exc_new2(cStreamEnd, msg);
00317         break;
00318       case Z_NEED_DICT:
00319         exc = rb_exc_new2(cNeedDict, msg);
00320         break;
00321       case Z_STREAM_ERROR:
00322         exc = rb_exc_new2(cStreamError, msg);
00323         break;
00324       case Z_DATA_ERROR:
00325         exc = rb_exc_new2(cDataError, msg);
00326         break;
00327       case Z_BUF_ERROR:
00328         exc = rb_exc_new2(cBufError, msg);
00329         break;
00330       case Z_VERSION_ERROR:
00331         exc = rb_exc_new2(cVersionError, msg);
00332         break;
00333       case Z_MEM_ERROR:
00334         exc = rb_exc_new2(cMemError, msg);
00335         break;
00336       case Z_ERRNO:
00337         rb_sys_fail(msg);
00338         /* no return */
00339       default:
00340       {
00341           char buf[BUFSIZ];
00342           snprintf(buf, BUFSIZ, "unknown zlib error %d: %s", err, msg);
00343           exc = rb_exc_new2(cZError, buf);
00344       }
00345     }
00346 
00347     rb_exc_raise(exc);
00348 }
00349 
00350 
00351 /*--- Warning (in finalizer) ---*/
00352 
00353 static void
00354 finalizer_warn(const char *msg)
00355 {
00356     fprintf(stderr, "zlib(finalizer): %s\n", msg);
00357 }
00358 
00359 
00360 /*-------- module Zlib --------*/
00361 
00362 /*
00363  * Document-method: Zlib.zlib_version
00364  *
00365  * Returns the string which represents the version of zlib library.
00366  */
00367 static VALUE
00368 rb_zlib_version(VALUE klass)
00369 {
00370     VALUE str;
00371 
00372     str = rb_str_new2(zlibVersion());
00373     OBJ_TAINT(str);  /* for safe */
00374     return str;
00375 }
00376 
00377 #if SIZEOF_LONG > SIZEOF_INT
00378 static uLong
00379 checksum_long(uLong (*func)(uLong, const Bytef*, uInt), uLong sum, const Bytef *ptr, long len)
00380 {
00381     if (len > UINT_MAX) {
00382         do {
00383             sum = func(sum, ptr, UINT_MAX);
00384             ptr += UINT_MAX;
00385             len -= UINT_MAX;
00386         } while (len >= UINT_MAX);
00387     }
00388     if (len > 0) sum = func(sum, ptr, (uInt)len);
00389     return sum;
00390 }
00391 #else
00392 #define checksum_long(func, sum, ptr, len) (func)((sum), (ptr), (len))
00393 #endif
00394 
00395 static VALUE
00396 do_checksum(argc, argv, func)
00397     int argc;
00398     VALUE *argv;
00399     uLong (*func)(uLong, const Bytef*, uInt);
00400 {
00401     VALUE str, vsum;
00402     unsigned long sum;
00403 
00404     rb_scan_args(argc, argv, "02", &str, &vsum);
00405 
00406     if (!NIL_P(vsum)) {
00407         sum = NUM2ULONG(vsum);
00408     }
00409     else if (NIL_P(str)) {
00410         sum = 0;
00411     }
00412     else {
00413         sum = func(0, Z_NULL, 0);
00414     }
00415 
00416     if (NIL_P(str)) {
00417         sum = func(sum, Z_NULL, 0);
00418     }
00419     else {
00420         StringValue(str);
00421         sum = checksum_long(func, sum, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
00422     }
00423     return rb_uint2inum(sum);
00424 }
00425 
00426 /*
00427  * Document-method: Zlib.adler32
00428  *
00429  * call-seq: Zlib.adler32(string, adler)
00430  *
00431  * Calculates Adler-32 checksum for +string+, and returns updated value of
00432  * +adler+. If +string+ is omitted, it returns the Adler-32 initial value. If
00433  * +adler+ is omitted, it assumes that the initial value is given to +adler+.
00434  *
00435  * FIXME: expression.
00436  */
00437 static VALUE
00438 rb_zlib_adler32(int argc, VALUE *argv, VALUE klass)
00439 {
00440     return do_checksum(argc, argv, adler32);
00441 }
00442 
00443 #ifdef HAVE_ADLER32_COMBINE
00444 /*
00445  * Document-method: Zlib.adler32_combine
00446  *
00447  * call-seq: Zlib.adler32_combine(adler1, adler2, len2)
00448  *
00449  * Combine two Adler-32 check values in to one.  +alder1+ is the first Adler-32
00450  * value, +adler2+ is the second Adler-32 value.  +len2+ is the length of the
00451  * string used to generate +adler2+.
00452  *
00453  */
00454 static VALUE
00455 rb_zlib_adler32_combine(VALUE klass, VALUE adler1, VALUE adler2, VALUE len2)
00456 {
00457   return ULONG2NUM(
00458         adler32_combine(NUM2ULONG(adler1), NUM2ULONG(adler2), NUM2LONG(len2)));
00459 }
00460 #else
00461 #define rb_zlib_adler32_combine rb_f_notimplement
00462 #endif
00463 
00464 /*
00465  * Document-method: Zlib.crc32
00466  *
00467  * call-seq: Zlib.crc32(string, adler)
00468  *
00469  * Calculates CRC checksum for +string+, and returns updated value of +crc+. If
00470  * +string+ is omitted, it returns the CRC initial value. If +crc+ is omitted, it
00471  * assumes that the initial value is given to +crc+.
00472  *
00473  * FIXME: expression.
00474  */
00475 static VALUE
00476 rb_zlib_crc32(int argc, VALUE *argv, VALUE klass)
00477 {
00478     return do_checksum(argc, argv, crc32);
00479 }
00480 
00481 #ifdef HAVE_CRC32_COMBINE
00482 /*
00483  * Document-method: Zlib.crc32_combine
00484  *
00485  * call-seq: Zlib.crc32_combine(crc1, crc2, len2)
00486  *
00487  * Combine two CRC-32 check values in to one.  +crc1+ is the first CRC-32
00488  * value, +crc2+ is the second CRC-32 value.  +len2+ is the length of the
00489  * string used to generate +crc2+.
00490  *
00491  */
00492 static VALUE
00493 rb_zlib_crc32_combine(VALUE klass, VALUE crc1, VALUE crc2, VALUE len2)
00494 {
00495   return ULONG2NUM(
00496         crc32_combine(NUM2ULONG(crc1), NUM2ULONG(crc2), NUM2LONG(len2)));
00497 }
00498 #else
00499 #define rb_zlib_crc32_combine rb_f_notimplement
00500 #endif
00501 
00502 /*
00503  * Document-method: Zlib.crc_table
00504  *
00505  * Returns the table for calculating CRC checksum as an array.
00506  */
00507 static VALUE
00508 rb_zlib_crc_table(VALUE obj)
00509 {
00510 #if !defined(HAVE_TYPE_Z_CRC_T)
00511     /* z_crc_t is defined since zlib-1.2.7. */
00512     typedef unsigned long z_crc_t;
00513 #endif
00514     const z_crc_t *crctbl;
00515     VALUE dst;
00516     int i;
00517 
00518     crctbl = get_crc_table();
00519     dst = rb_ary_new2(256);
00520 
00521     for (i = 0; i < 256; i++) {
00522         rb_ary_push(dst, rb_uint2inum(crctbl[i]));
00523     }
00524     return dst;
00525 }
00526 
00527 
00528 
00529 /*-------- zstream - internal APIs --------*/
00530 
00531 struct zstream {
00532     unsigned long flags;
00533     VALUE buf;
00534     long buf_filled;
00535     VALUE input;
00536     z_stream stream;
00537     const struct zstream_funcs {
00538         int (*reset)(z_streamp);
00539         int (*end)(z_streamp);
00540         int (*run)(z_streamp, int);
00541     } *func;
00542 };
00543 
00544 #define ZSTREAM_FLAG_READY      0x1
00545 #define ZSTREAM_FLAG_IN_STREAM  0x2
00546 #define ZSTREAM_FLAG_FINISHED   0x4
00547 #define ZSTREAM_FLAG_CLOSING    0x8
00548 #define ZSTREAM_FLAG_GZFILE     0x10 /* disallows yield from expand_buffer for
00549                                         gzip*/
00550 #define ZSTREAM_FLAG_UNUSED     0x20
00551 
00552 #define ZSTREAM_READY(z)       ((z)->flags |= ZSTREAM_FLAG_READY)
00553 #define ZSTREAM_IS_READY(z)    ((z)->flags & ZSTREAM_FLAG_READY)
00554 #define ZSTREAM_IS_FINISHED(z) ((z)->flags & ZSTREAM_FLAG_FINISHED)
00555 #define ZSTREAM_IS_CLOSING(z)  ((z)->flags & ZSTREAM_FLAG_CLOSING)
00556 #define ZSTREAM_IS_GZFILE(z)   ((z)->flags & ZSTREAM_FLAG_GZFILE)
00557 
00558 #define ZSTREAM_EXPAND_BUFFER_OK          0
00559 
00560 /* I think that more better value should be found,
00561    but I gave up finding it. B) */
00562 #define ZSTREAM_INITIAL_BUFSIZE       1024
00563 /* Allow a quick return when the thread is interrupted */
00564 #define ZSTREAM_AVAIL_OUT_STEP_MAX   16384
00565 #define ZSTREAM_AVAIL_OUT_STEP_MIN    2048
00566 
00567 static const struct zstream_funcs deflate_funcs = {
00568     deflateReset, deflateEnd, deflate,
00569 };
00570 
00571 static const struct zstream_funcs inflate_funcs = {
00572     inflateReset, inflateEnd, inflate,
00573 };
00574 
00575 struct zstream_run_args {
00576     struct zstream * z;
00577     int flush;         /* stream flush value for inflate() or deflate() */
00578     int interrupt;     /* stop processing the stream and return to ruby */
00579     int jump_state;    /* for buffer expansion block break or exception */
00580     int stream_output; /* for streaming zlib processing */
00581 };
00582 
00583 static voidpf
00584 zlib_mem_alloc(voidpf opaque, uInt items, uInt size)
00585 {
00586     voidpf p = xmalloc(items * size);
00587     /* zlib FAQ: Valgrind (or some similar memory access checker) says that
00588        deflate is performing a conditional jump that depends on an
00589        uninitialized value.  Isn't that a bug?
00590        http://www.zlib.net/zlib_faq.html#faq36 */
00591     (void)VALGRIND_MAKE_MEM_DEFINED(p, items * size);
00592     return p;
00593 }
00594 
00595 static void
00596 zlib_mem_free(voidpf opaque, voidpf address)
00597 {
00598     xfree(address);
00599 }
00600 
00601 static void
00602 zstream_init(struct zstream *z, const struct zstream_funcs *func)
00603 {
00604     z->flags = 0;
00605     z->buf = Qnil;
00606     z->buf_filled = 0;
00607     z->input = Qnil;
00608     z->stream.zalloc = zlib_mem_alloc;
00609     z->stream.zfree = zlib_mem_free;
00610     z->stream.opaque = Z_NULL;
00611     z->stream.msg = Z_NULL;
00612     z->stream.next_in = Z_NULL;
00613     z->stream.avail_in = 0;
00614     z->stream.next_out = Z_NULL;
00615     z->stream.avail_out = 0;
00616     z->func = func;
00617 }
00618 
00619 #define zstream_init_deflate(z)   zstream_init((z), &deflate_funcs)
00620 #define zstream_init_inflate(z)   zstream_init((z), &inflate_funcs)
00621 
00622 static void
00623 zstream_expand_buffer(struct zstream *z)
00624 {
00625     if (NIL_P(z->buf)) {
00626         zstream_expand_buffer_into(z, ZSTREAM_INITIAL_BUFSIZE);
00627         return;
00628     }
00629 
00630     if (!ZSTREAM_IS_GZFILE(z) && rb_block_given_p()) {
00631         if (z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
00632             int state = 0;
00633             VALUE self = (VALUE)z->stream.opaque;
00634 
00635             rb_str_resize(z->buf, z->buf_filled);
00636             RBASIC(z->buf)->klass = rb_cString;
00637             OBJ_INFECT(z->buf, self);
00638 
00639             rb_protect(rb_yield, z->buf, &state);
00640 
00641             z->buf = Qnil;
00642             zstream_expand_buffer_into(z, ZSTREAM_AVAIL_OUT_STEP_MAX);
00643 
00644             if (state)
00645                 rb_jump_tag(state);
00646 
00647             return;
00648         }
00649         else {
00650             zstream_expand_buffer_into(z,
00651                     ZSTREAM_AVAIL_OUT_STEP_MAX - z->buf_filled);
00652         }
00653     }
00654     else {
00655         if (RSTRING_LEN(z->buf) - z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
00656             z->stream.avail_out = ZSTREAM_AVAIL_OUT_STEP_MAX;
00657         }
00658         else {
00659             long inc = z->buf_filled / 2;
00660             if (inc < ZSTREAM_AVAIL_OUT_STEP_MIN) {
00661                 inc = ZSTREAM_AVAIL_OUT_STEP_MIN;
00662             }
00663             rb_str_resize(z->buf, z->buf_filled + inc);
00664             z->stream.avail_out = (inc < ZSTREAM_AVAIL_OUT_STEP_MAX) ?
00665                 (int)inc : ZSTREAM_AVAIL_OUT_STEP_MAX;
00666         }
00667         z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
00668     }
00669 }
00670 
00671 static void
00672 zstream_expand_buffer_into(struct zstream *z, unsigned long size)
00673 {
00674     if (NIL_P(z->buf)) {
00675         /* I uses rb_str_new here not rb_str_buf_new because
00676            rb_str_buf_new makes a zero-length string. */
00677         z->buf = rb_str_new(0, size);
00678         z->buf_filled = 0;
00679         z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
00680         z->stream.avail_out = MAX_UINT(size);
00681         RBASIC(z->buf)->klass = 0;
00682     }
00683     else if (z->stream.avail_out != size) {
00684         rb_str_resize(z->buf, z->buf_filled + size);
00685         z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
00686         z->stream.avail_out = MAX_UINT(size);
00687     }
00688 }
00689 
00690 static void *
00691 zstream_expand_buffer_protect(void *ptr)
00692 {
00693     struct zstream *z = (struct zstream *)ptr;
00694     int state = 0;
00695 
00696     rb_protect((VALUE (*)(VALUE))zstream_expand_buffer, (VALUE)z, &state);
00697 
00698     return (void *)(VALUE)state;
00699 }
00700 
00701 static int
00702 zstream_expand_buffer_without_gvl(struct zstream *z)
00703 {
00704     char * new_str;
00705     long inc, len;
00706 
00707     if (RSTRING_LEN(z->buf) - z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
00708         z->stream.avail_out = ZSTREAM_AVAIL_OUT_STEP_MAX;
00709     }
00710     else {
00711         inc = z->buf_filled / 2;
00712         if (inc < ZSTREAM_AVAIL_OUT_STEP_MIN) {
00713             inc = ZSTREAM_AVAIL_OUT_STEP_MIN;
00714         }
00715 
00716         len = z->buf_filled + inc;
00717 
00718         new_str = ruby_xrealloc(RSTRING(z->buf)->as.heap.ptr, len + 1);
00719 
00720         /* from rb_str_resize */
00721         RSTRING(z->buf)->as.heap.ptr = new_str;
00722         RSTRING(z->buf)->as.heap.ptr[len] = '\0'; /* sentinel */
00723         RSTRING(z->buf)->as.heap.len =
00724             RSTRING(z->buf)->as.heap.aux.capa = len;
00725 
00726         z->stream.avail_out = (inc < ZSTREAM_AVAIL_OUT_STEP_MAX) ?
00727             (int)inc : ZSTREAM_AVAIL_OUT_STEP_MAX;
00728     }
00729     z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
00730 
00731     return ZSTREAM_EXPAND_BUFFER_OK;
00732 }
00733 
00734 static void
00735 zstream_append_buffer(struct zstream *z, const Bytef *src, long len)
00736 {
00737     if (NIL_P(z->buf)) {
00738         z->buf = rb_str_buf_new(len);
00739         rb_str_buf_cat(z->buf, (const char*)src, len);
00740         z->buf_filled = len;
00741         z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
00742         z->stream.avail_out = 0;
00743         RBASIC(z->buf)->klass = 0;
00744         return;
00745     }
00746 
00747     if (RSTRING_LEN(z->buf) < z->buf_filled + len) {
00748         rb_str_resize(z->buf, z->buf_filled + len);
00749         z->stream.avail_out = 0;
00750     }
00751     else {
00752         if (z->stream.avail_out >= (uInt)len) {
00753             z->stream.avail_out -= (uInt)len;
00754         }
00755         else {
00756             z->stream.avail_out = 0;
00757         }
00758     }
00759     memcpy(RSTRING_PTR(z->buf) + z->buf_filled, src, len);
00760     z->buf_filled += len;
00761     z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
00762 }
00763 
00764 #define zstream_append_buffer2(z,v) \
00765     zstream_append_buffer((z),(Bytef*)RSTRING_PTR(v),RSTRING_LEN(v))
00766 
00767 static VALUE
00768 zstream_detach_buffer(struct zstream *z)
00769 {
00770     VALUE dst, self = (VALUE)z->stream.opaque;
00771 
00772     if (!ZSTREAM_IS_FINISHED(z) && !ZSTREAM_IS_GZFILE(z) &&
00773             rb_block_given_p()) {
00774         /* prevent tiny yields mid-stream, save for next
00775          * zstream_expand_buffer() or stream end */
00776         return Qnil;
00777     }
00778 
00779     if (NIL_P(z->buf)) {
00780         dst = rb_str_new(0, 0);
00781     }
00782     else {
00783         dst = z->buf;
00784         rb_str_resize(dst, z->buf_filled);
00785         RBASIC(dst)->klass = rb_cString;
00786     }
00787 
00788     OBJ_INFECT(dst, self);
00789 
00790     z->buf = Qnil;
00791     z->buf_filled = 0;
00792     z->stream.next_out = 0;
00793     z->stream.avail_out = 0;
00794 
00795     if (!ZSTREAM_IS_GZFILE(z) && rb_block_given_p()) {
00796         rb_yield(dst);
00797         dst = Qnil;
00798     }
00799 
00800     return dst;
00801 }
00802 
00803 static VALUE
00804 zstream_shift_buffer(struct zstream *z, long len)
00805 {
00806     VALUE dst;
00807     long buflen;
00808 
00809     if (z->buf_filled <= len) {
00810         return zstream_detach_buffer(z);
00811     }
00812 
00813     dst = rb_str_subseq(z->buf, 0, len);
00814     RBASIC(dst)->klass = rb_cString;
00815     z->buf_filled -= len;
00816     memmove(RSTRING_PTR(z->buf), RSTRING_PTR(z->buf) + len,
00817             z->buf_filled);
00818     z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
00819     buflen = RSTRING_LEN(z->buf) - z->buf_filled;
00820     if (buflen > ZSTREAM_AVAIL_OUT_STEP_MAX) {
00821         buflen = ZSTREAM_AVAIL_OUT_STEP_MAX;
00822     }
00823     z->stream.avail_out = (uInt)buflen;
00824 
00825     return dst;
00826 }
00827 
00828 static void
00829 zstream_buffer_ungets(struct zstream *z, const Bytef *b, unsigned long len)
00830 {
00831     if (NIL_P(z->buf) || RSTRING_LEN(z->buf) - z->buf_filled == 0) {
00832         zstream_expand_buffer_into(z, len);
00833     }
00834 
00835     memmove(RSTRING_PTR(z->buf) + len, RSTRING_PTR(z->buf), z->buf_filled);
00836     memmove(RSTRING_PTR(z->buf), b, len);
00837     z->buf_filled+=len;
00838     if (z->stream.avail_out > 0) {
00839         if (len > z->stream.avail_out) len = z->stream.avail_out;
00840         z->stream.next_out+=len;
00841         z->stream.avail_out-=(uInt)len;
00842     }
00843 }
00844 
00845 static void
00846 zstream_buffer_ungetbyte(struct zstream *z, int c)
00847 {
00848     if (NIL_P(z->buf) || RSTRING_LEN(z->buf) - z->buf_filled == 0) {
00849         zstream_expand_buffer(z);
00850     }
00851 
00852     memmove(RSTRING_PTR(z->buf) + 1, RSTRING_PTR(z->buf), z->buf_filled);
00853     RSTRING_PTR(z->buf)[0] = (char)c;
00854     z->buf_filled++;
00855     if (z->stream.avail_out > 0) {
00856         z->stream.next_out++;
00857         z->stream.avail_out--;
00858     }
00859 }
00860 
00861 static void
00862 zstream_append_input(struct zstream *z, const Bytef *src, long len)
00863 {
00864     if (len <= 0) return;
00865 
00866     if (NIL_P(z->input)) {
00867         z->input = rb_str_buf_new(len);
00868         rb_str_buf_cat(z->input, (const char*)src, len);
00869         RBASIC(z->input)->klass = 0;
00870     }
00871     else {
00872         rb_str_buf_cat(z->input, (const char*)src, len);
00873     }
00874 }
00875 
00876 #define zstream_append_input2(z,v)\
00877     RB_GC_GUARD(v),\
00878     zstream_append_input((z), (Bytef*)RSTRING_PTR(v), RSTRING_LEN(v))
00879 
00880 static void
00881 zstream_discard_input(struct zstream *z, long len)
00882 {
00883     if (NIL_P(z->input) || RSTRING_LEN(z->input) <= len) {
00884         z->input = Qnil;
00885     }
00886     else {
00887         memmove(RSTRING_PTR(z->input), RSTRING_PTR(z->input) + len,
00888                 RSTRING_LEN(z->input) - len);
00889         rb_str_resize(z->input, RSTRING_LEN(z->input) - len);
00890     }
00891 }
00892 
00893 static void
00894 zstream_reset_input(struct zstream *z)
00895 {
00896     z->input = Qnil;
00897 }
00898 
00899 static void
00900 zstream_passthrough_input(struct zstream *z)
00901 {
00902     if (!NIL_P(z->input)) {
00903         zstream_append_buffer2(z, z->input);
00904         z->input = Qnil;
00905     }
00906 }
00907 
00908 static VALUE
00909 zstream_detach_input(struct zstream *z)
00910 {
00911     VALUE dst;
00912 
00913     if (NIL_P(z->input)) {
00914         dst = rb_str_new(0, 0);
00915     }
00916     else {
00917         dst = z->input;
00918         RBASIC(dst)->klass = rb_cString;
00919     }
00920     z->input = Qnil;
00921     RBASIC(dst)->klass = rb_cString;
00922     return dst;
00923 }
00924 
00925 static void
00926 zstream_reset(struct zstream *z)
00927 {
00928     int err;
00929 
00930     err = z->func->reset(&z->stream);
00931     if (err != Z_OK) {
00932         raise_zlib_error(err, z->stream.msg);
00933     }
00934     z->flags = ZSTREAM_FLAG_READY;
00935     z->buf = Qnil;
00936     z->buf_filled = 0;
00937     z->stream.next_out = 0;
00938     z->stream.avail_out = 0;
00939     zstream_reset_input(z);
00940 }
00941 
00942 static VALUE
00943 zstream_end(struct zstream *z)
00944 {
00945     int err;
00946 
00947     if (!ZSTREAM_IS_READY(z)) {
00948         rb_warning("attempt to close uninitialized zstream; ignored.");
00949         return Qnil;
00950     }
00951     if (z->flags & ZSTREAM_FLAG_IN_STREAM) {
00952         rb_warning("attempt to close unfinished zstream; reset forced.");
00953         zstream_reset(z);
00954     }
00955 
00956     zstream_reset_input(z);
00957     err = z->func->end(&z->stream);
00958     if (err != Z_OK) {
00959         raise_zlib_error(err, z->stream.msg);
00960     }
00961     z->flags = 0;
00962     return Qnil;
00963 }
00964 
00965 static void *
00966 zstream_run_func(void *ptr)
00967 {
00968     struct zstream_run_args *args = (struct zstream_run_args *)ptr;
00969     int err, state, flush = args->flush;
00970     struct zstream *z = args->z;
00971     uInt n;
00972 
00973     err = Z_OK;
00974     while (!args->interrupt) {
00975         n = z->stream.avail_out;
00976         err = z->func->run(&z->stream, flush);
00977         z->buf_filled += n - z->stream.avail_out;
00978 
00979         if (err == Z_STREAM_END) {
00980             z->flags &= ~ZSTREAM_FLAG_IN_STREAM;
00981             z->flags |= ZSTREAM_FLAG_FINISHED;
00982             break;
00983         }
00984 
00985         if (err != Z_OK && err != Z_BUF_ERROR)
00986             break;
00987 
00988         if (z->stream.avail_out > 0) {
00989             z->flags |= ZSTREAM_FLAG_IN_STREAM;
00990             break;
00991         }
00992 
00993         if (z->stream.avail_in == 0 && z->func == &inflate_funcs) {
00994             /* break here because inflate() return Z_BUF_ERROR when avail_in == 0. */
00995             /* but deflate() could be called with avail_in == 0 (there's hidden buffer
00996                in zstream->state) */
00997             z->flags |= ZSTREAM_FLAG_IN_STREAM;
00998             break;
00999         }
01000 
01001         if (args->stream_output) {
01002             state = (int)(VALUE)rb_thread_call_with_gvl(zstream_expand_buffer_protect,
01003                                                         (void *)z);
01004         } else {
01005             state = zstream_expand_buffer_without_gvl(z);
01006         }
01007 
01008         if (state) {
01009             err = Z_OK; /* buffer expanded but stream processing was stopped */
01010             args->jump_state = state;
01011             break;
01012         }
01013     }
01014 
01015     return (void *)(VALUE)err;
01016 }
01017 
01018 /*
01019  * There is no safe way to interrupt z->run->func().
01020  */
01021 static void
01022 zstream_unblock_func(void *ptr)
01023 {
01024     struct zstream_run_args *args = (struct zstream_run_args *)ptr;
01025 
01026     args->interrupt = 1;
01027 }
01028 
01029 static void
01030 zstream_run(struct zstream *z, Bytef *src, long len, int flush)
01031 {
01032     struct zstream_run_args args;
01033     int err;
01034     volatile VALUE guard = Qnil;
01035 
01036     args.z = z;
01037     args.flush = flush;
01038     args.interrupt = 0;
01039     args.jump_state = 0;
01040     args.stream_output = !ZSTREAM_IS_GZFILE(z) && rb_block_given_p();
01041 
01042     if (NIL_P(z->input) && len == 0) {
01043         z->stream.next_in = (Bytef*)"";
01044         z->stream.avail_in = 0;
01045     }
01046     else {
01047         zstream_append_input(z, src, len);
01048         z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
01049         z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
01050         /* keep reference to `z->input' so as not to be garbage collected
01051            after zstream_reset_input() and prevent `z->stream.next_in'
01052            from dangling. */
01053         guard = z->input;
01054     }
01055 
01056     if (z->stream.avail_out == 0) {
01057         zstream_expand_buffer(z);
01058     }
01059 
01060 loop:
01061     err = (int)(VALUE)rb_thread_call_without_gvl(zstream_run_func, (void *)&args,
01062                                                  zstream_unblock_func, (void *)&args);
01063 
01064     if (flush != Z_FINISH && err == Z_BUF_ERROR
01065             && z->stream.avail_out > 0) {
01066         z->flags |= ZSTREAM_FLAG_IN_STREAM;
01067     }
01068 
01069     zstream_reset_input(z);
01070 
01071     if (err != Z_OK && err != Z_STREAM_END) {
01072         if (z->stream.avail_in > 0) {
01073             zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
01074         }
01075         if (err == Z_NEED_DICT) {
01076             VALUE self = (VALUE)z->stream.opaque;
01077             VALUE dicts = rb_ivar_get(self, id_dictionaries);
01078             VALUE dict = rb_hash_aref(dicts, rb_uint2inum(z->stream.adler));
01079             if (!NIL_P(dict)) {
01080                 rb_inflate_set_dictionary(self, dict);
01081                 goto loop;
01082             }
01083         }
01084         raise_zlib_error(err, z->stream.msg);
01085     }
01086 
01087     if (z->stream.avail_in > 0) {
01088         zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
01089         RB_GC_GUARD(guard) = Qnil; /* prevent tail call to make guard effective */
01090     }
01091 
01092     if (args.jump_state)
01093         rb_jump_tag(args.jump_state);
01094 }
01095 
01096 static VALUE
01097 zstream_sync(struct zstream *z, Bytef *src, long len)
01098 {
01099     /* VALUE rest; */
01100     int err;
01101 
01102     if (!NIL_P(z->input)) {
01103         z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
01104         z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
01105         err = inflateSync(&z->stream);
01106         if (err == Z_OK) {
01107             zstream_discard_input(z,
01108                                   RSTRING_LEN(z->input) - z->stream.avail_in);
01109             zstream_append_input(z, src, len);
01110             return Qtrue;
01111         }
01112         zstream_reset_input(z);
01113         if (err != Z_DATA_ERROR) {
01114             /* rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in); */
01115             raise_zlib_error(err, z->stream.msg);
01116         }
01117     }
01118 
01119     if (len <= 0) return Qfalse;
01120 
01121     z->stream.next_in = src;
01122     z->stream.avail_in = MAX_UINT(len);
01123     err = inflateSync(&z->stream);
01124     if (err == Z_OK) {
01125         zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
01126         return Qtrue;
01127     }
01128     if (err != Z_DATA_ERROR) {
01129         /* rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in); */
01130         raise_zlib_error(err, z->stream.msg);
01131     }
01132     return Qfalse;
01133 }
01134 
01135 static void
01136 zstream_mark(struct zstream *z)
01137 {
01138     rb_gc_mark(z->buf);
01139     rb_gc_mark(z->input);
01140 }
01141 
01142 static void
01143 zstream_finalize(struct zstream *z)
01144 {
01145     int err = z->func->end(&z->stream);
01146     if (err == Z_STREAM_ERROR)
01147         finalizer_warn("the stream state was inconsistent.");
01148     if (err == Z_DATA_ERROR)
01149         finalizer_warn("the stream was freed prematurely.");
01150 }
01151 
01152 static void
01153 zstream_free(struct zstream *z)
01154 {
01155     if (ZSTREAM_IS_READY(z)) {
01156         zstream_finalize(z);
01157     }
01158     xfree(z);
01159 }
01160 
01161 static VALUE
01162 zstream_new(VALUE klass, const struct zstream_funcs *funcs)
01163 {
01164     VALUE obj;
01165     struct zstream *z;
01166 
01167     obj = Data_Make_Struct(klass, struct zstream,
01168                            zstream_mark, zstream_free, z);
01169     zstream_init(z, funcs);
01170     z->stream.opaque = (voidpf)obj;
01171     return obj;
01172 }
01173 
01174 #define zstream_deflate_new(klass)  zstream_new((klass), &deflate_funcs)
01175 #define zstream_inflate_new(klass)  zstream_new((klass), &inflate_funcs)
01176 
01177 static struct zstream *
01178 get_zstream(VALUE obj)
01179 {
01180     struct zstream *z;
01181 
01182     Data_Get_Struct(obj, struct zstream, z);
01183     if (!ZSTREAM_IS_READY(z)) {
01184         rb_raise(cZError, "stream is not ready");
01185     }
01186     return z;
01187 }
01188 
01189 
01190 /* ------------------------------------------------------------------------- */
01191 
01192 /*
01193  * Document-class: Zlib::ZStream
01194  *
01195  * Zlib::ZStream is the abstract class for the stream which handles the
01196  * compressed data. The operations are defined in the subclasses:
01197  * Zlib::Deflate for compression, and Zlib::Inflate for decompression.
01198  *
01199  * An instance of Zlib::ZStream has one stream (struct zstream in the source)
01200  * and two variable-length buffers which associated to the input (next_in) of
01201  * the stream and the output (next_out) of the stream. In this document,
01202  * "input buffer" means the buffer for input, and "output buffer" means the
01203  * buffer for output.
01204  *
01205  * Data input into an instance of Zlib::ZStream are temporally stored into
01206  * the end of input buffer, and then data in input buffer are processed from
01207  * the beginning of the buffer until no more output from the stream is
01208  * produced (i.e. until avail_out > 0 after processing).  During processing,
01209  * output buffer is allocated and expanded automatically to hold all output
01210  * data.
01211  *
01212  * Some particular instance methods consume the data in output buffer and
01213  * return them as a String.
01214  *
01215  * Here is an ascii art for describing above:
01216  *
01217  *    +================ an instance of Zlib::ZStream ================+
01218  *    ||                                                            ||
01219  *    ||     +--------+          +-------+          +--------+      ||
01220  *    ||  +--| output |<---------|zstream|<---------| input  |<--+  ||
01221  *    ||  |  | buffer |  next_out+-------+next_in   | buffer |   |  ||
01222  *    ||  |  +--------+                             +--------+   |  ||
01223  *    ||  |                                                      |  ||
01224  *    +===|======================================================|===+
01225  *        |                                                      |
01226  *        v                                                      |
01227  *    "output data"                                         "input data"
01228  *
01229  * If an error occurs during processing input buffer, an exception which is a
01230  * subclass of Zlib::Error is raised.  At that time, both input and output
01231  * buffer keep their conditions at the time when the error occurs.
01232  *
01233  * == Method Catalogue
01234  *
01235  * Many of the methods in this class are fairly low-level and unlikely to be
01236  * of interest to users.  In fact, users are unlikely to use this class
01237  * directly; rather they will be interested in Zlib::Inflate and
01238  * Zlib::Deflate.
01239  *
01240  * The higher level methods are listed below.
01241  *
01242  * - #total_in
01243  * - #total_out
01244  * - #data_type
01245  * - #adler
01246  * - #reset
01247  * - #finish
01248  * - #finished?
01249  * - #close
01250  * - #closed?
01251  */
01252 
01253 /*
01254  * Closes the stream. All operations on the closed stream will raise an
01255  * exception.
01256  */
01257 static VALUE
01258 rb_zstream_end(VALUE obj)
01259 {
01260     zstream_end(get_zstream(obj));
01261     return Qnil;
01262 }
01263 
01264 /*
01265  * Resets and initializes the stream. All data in both input and output buffer
01266  * are discarded.
01267  */
01268 static VALUE
01269 rb_zstream_reset(VALUE obj)
01270 {
01271     zstream_reset(get_zstream(obj));
01272     return Qnil;
01273 }
01274 
01275 /*
01276  * call-seq:
01277  *   finish                 -> String
01278  *   finish { |chunk| ... } -> nil
01279  *
01280  * Finishes the stream and flushes output buffer.  If a block is given each
01281  * chunk is yielded to the block until the input buffer has been flushed to
01282  * the output buffer.
01283  */
01284 static VALUE
01285 rb_zstream_finish(VALUE obj)
01286 {
01287     struct zstream *z = get_zstream(obj);
01288 
01289     zstream_run(z, (Bytef*)"", 0, Z_FINISH);
01290 
01291     return zstream_detach_buffer(z);
01292 }
01293 
01294 /*
01295  * call-seq:
01296  *   flush_next_out                 -> String
01297  *   flush_next_out { |chunk| ... } -> nil
01298  *
01299  * Flushes output buffer and returns all data in that buffer.  If a block is
01300  * given each chunk is yielded to the block until the current output buffer
01301  * has been flushed.
01302  */
01303 static VALUE
01304 rb_zstream_flush_next_in(VALUE obj)
01305 {
01306     struct zstream *z;
01307     VALUE dst;
01308 
01309     Data_Get_Struct(obj, struct zstream, z);
01310     dst = zstream_detach_input(z);
01311     OBJ_INFECT(dst, obj);
01312     return dst;
01313 }
01314 
01315 /*
01316  * Flushes output buffer and returns all data in that buffer.
01317  */
01318 static VALUE
01319 rb_zstream_flush_next_out(VALUE obj)
01320 {
01321     struct zstream *z;
01322 
01323     Data_Get_Struct(obj, struct zstream, z);
01324 
01325     return zstream_detach_buffer(z);
01326 }
01327 
01328 /*
01329  * Returns number of bytes of free spaces in output buffer.  Because the free
01330  * space is allocated automatically, this method returns 0 normally.
01331  */
01332 static VALUE
01333 rb_zstream_avail_out(VALUE obj)
01334 {
01335     struct zstream *z;
01336     Data_Get_Struct(obj, struct zstream, z);
01337     return rb_uint2inum(z->stream.avail_out);
01338 }
01339 
01340 /*
01341  * Allocates +size+ bytes of free space in the output buffer. If there are more
01342  * than +size+ bytes already in the buffer, the buffer is truncated. Because
01343  * free space is allocated automatically, you usually don't need to use this
01344  * method.
01345  */
01346 static VALUE
01347 rb_zstream_set_avail_out(VALUE obj, VALUE size)
01348 {
01349     struct zstream *z = get_zstream(obj);
01350 
01351     Check_Type(size, T_FIXNUM);
01352     zstream_expand_buffer_into(z, FIX2INT(size));
01353     return size;
01354 }
01355 
01356 /*
01357  * Returns bytes of data in the input buffer. Normally, returns 0.
01358  */
01359 static VALUE
01360 rb_zstream_avail_in(VALUE obj)
01361 {
01362     struct zstream *z;
01363     Data_Get_Struct(obj, struct zstream, z);
01364     return INT2FIX(NIL_P(z->input) ? 0 : (int)(RSTRING_LEN(z->input)));
01365 }
01366 
01367 /*
01368  * Returns the total bytes of the input data to the stream.  FIXME
01369  */
01370 static VALUE
01371 rb_zstream_total_in(VALUE obj)
01372 {
01373     return rb_uint2inum(get_zstream(obj)->stream.total_in);
01374 }
01375 
01376 /*
01377  * Returns the total bytes of the output data from the stream.  FIXME
01378  */
01379 static VALUE
01380 rb_zstream_total_out(VALUE obj)
01381 {
01382     return rb_uint2inum(get_zstream(obj)->stream.total_out);
01383 }
01384 
01385 /*
01386  * Guesses the type of the data which have been inputed into the stream. The
01387  * returned value is either <tt>BINARY</tt>, <tt>ASCII</tt>, or
01388  * <tt>UNKNOWN</tt>.
01389  */
01390 static VALUE
01391 rb_zstream_data_type(VALUE obj)
01392 {
01393     return INT2FIX(get_zstream(obj)->stream.data_type);
01394 }
01395 
01396 /*
01397  * Returns the adler-32 checksum.
01398  */
01399 static VALUE
01400 rb_zstream_adler(VALUE obj)
01401 {
01402         return rb_uint2inum(get_zstream(obj)->stream.adler);
01403 }
01404 
01405 /*
01406  * Returns true if the stream is finished.
01407  */
01408 static VALUE
01409 rb_zstream_finished_p(VALUE obj)
01410 {
01411     return ZSTREAM_IS_FINISHED(get_zstream(obj)) ? Qtrue : Qfalse;
01412 }
01413 
01414 /*
01415  * Returns true if the stream is closed.
01416  */
01417 static VALUE
01418 rb_zstream_closed_p(VALUE obj)
01419 {
01420     struct zstream *z;
01421     Data_Get_Struct(obj, struct zstream, z);
01422     return ZSTREAM_IS_READY(z) ? Qfalse : Qtrue;
01423 }
01424 
01425 
01426 /* ------------------------------------------------------------------------- */
01427 
01428 /*
01429  * Document-class: Zlib::Deflate
01430  *
01431  * Zlib::Deflate is the class for compressing data.  See Zlib::ZStream for more
01432  * information.
01433  */
01434 
01435 #define FIXNUMARG(val, ifnil) \
01436     (NIL_P((val)) ? (ifnil) \
01437     : ((void)Check_Type((val), T_FIXNUM), FIX2INT((val))))
01438 
01439 #define ARG_LEVEL(val)     FIXNUMARG((val), Z_DEFAULT_COMPRESSION)
01440 #define ARG_WBITS(val)     FIXNUMARG((val), MAX_WBITS)
01441 #define ARG_MEMLEVEL(val)  FIXNUMARG((val), DEF_MEM_LEVEL)
01442 #define ARG_STRATEGY(val)  FIXNUMARG((val), Z_DEFAULT_STRATEGY)
01443 #define ARG_FLUSH(val)     FIXNUMARG((val), Z_NO_FLUSH)
01444 
01445 
01446 static VALUE
01447 rb_deflate_s_allocate(VALUE klass)
01448 {
01449     return zstream_deflate_new(klass);
01450 }
01451 
01452 /*
01453  * Document-method: Zlib::Deflate.new
01454  *
01455  * call-seq:
01456  *   Zlib::Deflate.new(level=DEFAULT_COMPRESSION, window_bits=MAX_WBITS, mem_level=DEF_MEM_LEVEL, strategy=DEFAULT_STRATEGY)
01457  *
01458  * Creates a new deflate stream for compression. If a given argument is nil,
01459  * the default value of that argument is used.
01460  *
01461  * The +level+ sets the compression level for the deflate stream between 0 (no
01462  * compression) and 9 (best compression. The following constants have been
01463  * defined to make code more readable:
01464  *
01465  * * Zlib::NO_COMPRESSION = 0
01466  * * Zlib::BEST_SPEED = 1
01467  * * Zlib::DEFAULT_COMPRESSION = 6
01468  * * Zlib::BEST_COMPRESSION = 9
01469  *
01470  * The +window_bits+ sets the size of the history buffer and should be between
01471  * 8 and 15.  Larger values of this parameter result in better compression at
01472  * the expense of memory usage.
01473  *
01474  * The +mem_level+ specifies how much memory should be allocated for the
01475  * internal compression state.  1 uses minimum memory but is slow and reduces
01476  * compression ratio while 9 uses maximum memory for optimal speed.  The
01477  * default value is 8. Two constants are defined:
01478  *
01479  * * Zlib::DEF_MEM_LEVEL
01480  * * Zlib::MAX_MEM_LEVEL
01481  *
01482  * The +strategy+ sets the deflate compression strategy.  The following
01483  * strategies are available:
01484  *
01485  * Zlib::DEFAULT_STRATEGY:: For normal data
01486  * Zlib::FILTERED:: For data produced by a filter or predictor
01487  * Zlib::FIXED:: Prevents dynamic Huffman codes
01488  * Zlib::HUFFMAN_ONLY:: Prevents string matching
01489  * Zlib::RLE:: Designed for better compression of PNG image data
01490  *
01491  * See the constants for further description.
01492  *
01493  * == Examples
01494  *
01495  * === Basic
01496  *
01497  *   open "compressed.file", "w+" do |io|
01498  *     io << Zlib::Deflate.new.deflate(File.read("big.file"))
01499  *   end
01500  *
01501  * === Custom compression
01502  *
01503  *   open "compressed.file", "w+" do |compressed_io|
01504  *     deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
01505  *                                 Zlib::MAX_WBITS,
01506  *                                 Zlib::MAX_MEM_LEVEL,
01507  *                                 Zlib::HUFFMAN_ONLY)
01508  *
01509  *     begin
01510  *       open "big.file" do |big_io|
01511  *         until big_io.eof? do
01512  *           compressed_io << zd.deflate(big_io.read(16384))
01513  *         end
01514  *       end
01515  *     ensure
01516  *       deflate.close
01517  *     end
01518  *   end
01519  *
01520  * While this example will work, for best optimization review the flags for
01521  * your specific time, memory usage and output space requirements.
01522  */
01523 static VALUE
01524 rb_deflate_initialize(int argc, VALUE *argv, VALUE obj)
01525 {
01526     struct zstream *z;
01527     VALUE level, wbits, memlevel, strategy;
01528     int err;
01529 
01530     rb_scan_args(argc, argv, "04", &level, &wbits, &memlevel, &strategy);
01531     Data_Get_Struct(obj, struct zstream, z);
01532 
01533     err = deflateInit2(&z->stream, ARG_LEVEL(level), Z_DEFLATED,
01534                        ARG_WBITS(wbits), ARG_MEMLEVEL(memlevel),
01535                        ARG_STRATEGY(strategy));
01536     if (err != Z_OK) {
01537         raise_zlib_error(err, z->stream.msg);
01538     }
01539     ZSTREAM_READY(z);
01540 
01541     return obj;
01542 }
01543 
01544 /*
01545  * Document-method: Zlib::Deflate#initialize_copy
01546  *
01547  * Duplicates the deflate stream.
01548  */
01549 static VALUE
01550 rb_deflate_init_copy(VALUE self, VALUE orig)
01551 {
01552     struct zstream *z1, *z2;
01553     int err;
01554 
01555     Data_Get_Struct(self, struct zstream, z1);
01556     z2 = get_zstream(orig);
01557 
01558     err = deflateCopy(&z1->stream, &z2->stream);
01559     if (err != Z_OK) {
01560         raise_zlib_error(err, 0);
01561     }
01562     z1->input = NIL_P(z2->input) ? Qnil : rb_str_dup(z2->input);
01563     z1->buf   = NIL_P(z2->buf)   ? Qnil : rb_str_dup(z2->buf);
01564     z1->buf_filled = z2->buf_filled;
01565     z1->flags = z2->flags;
01566 
01567     return self;
01568 }
01569 
01570 static VALUE
01571 deflate_run(VALUE args)
01572 {
01573     struct zstream *z = (struct zstream*)((VALUE*)args)[0];
01574     VALUE src = ((VALUE*)args)[1];
01575 
01576     zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_FINISH);
01577     return zstream_detach_buffer(z);
01578 }
01579 
01580 /*
01581  * Document-method: Zlib::Deflate.deflate
01582  *
01583  * call-seq:
01584  *   Zlib.deflate(string[, level])
01585  *   Zlib::Deflate.deflate(string[, level])
01586  *
01587  * Compresses the given +string+. Valid values of level are
01588  * Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION,
01589  * Zlib::DEFAULT_COMPRESSION, or an integer from 0 to 9 (the default is 6).
01590  *
01591  * This method is almost equivalent to the following code:
01592  *
01593  *   def deflate(string, level)
01594  *     z = Zlib::Deflate.new(level)
01595  *     dst = z.deflate(string, Zlib::FINISH)
01596  *     z.close
01597  *     dst
01598  *   end
01599  *
01600  * See also Zlib.inflate
01601  *
01602  */
01603 static VALUE
01604 rb_deflate_s_deflate(int argc, VALUE *argv, VALUE klass)
01605 {
01606     struct zstream z;
01607     VALUE src, level, dst, args[2];
01608     int err, lev;
01609 
01610     rb_scan_args(argc, argv, "11", &src, &level);
01611 
01612     lev = ARG_LEVEL(level);
01613     StringValue(src);
01614     zstream_init_deflate(&z);
01615     err = deflateInit(&z.stream, lev);
01616     if (err != Z_OK) {
01617         raise_zlib_error(err, z.stream.msg);
01618     }
01619     ZSTREAM_READY(&z);
01620 
01621     args[0] = (VALUE)&z;
01622     args[1] = src;
01623     dst = rb_ensure(deflate_run, (VALUE)args, zstream_end, (VALUE)&z);
01624 
01625     OBJ_INFECT(dst, src);
01626     return dst;
01627 }
01628 
01629 static void
01630 do_deflate(struct zstream *z, VALUE src, int flush)
01631 {
01632     if (NIL_P(src)) {
01633         zstream_run(z, (Bytef*)"", 0, Z_FINISH);
01634         return;
01635     }
01636     StringValue(src);
01637     if (flush != Z_NO_FLUSH || RSTRING_LEN(src) > 0) { /* prevent BUF_ERROR */
01638         zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), flush);
01639     }
01640 }
01641 
01642 /*
01643  * Document-method: Zlib::Deflate#deflate
01644  *
01645  * call-seq:
01646  *   z.deflate(string, flush = Zlib::NO_FLUSH)                 -> String
01647  *   z.deflate(string, flush = Zlib::NO_FLUSH) { |chunk| ... } -> nil
01648  *
01649  * Inputs +string+ into the deflate stream and returns the output from the
01650  * stream.  On calling this method, both the input and the output buffers of
01651  * the stream are flushed.  If +string+ is nil, this method finishes the
01652  * stream, just like Zlib::ZStream#finish.
01653  *
01654  * If a block is given consecutive deflated chunks from the +string+ are
01655  * yielded to the block and +nil+ is returned.
01656  *
01657  * The +flush+ parameter specifies the flush mode.  The following constants
01658  * may be used:
01659  *
01660  * Zlib::NO_FLUSH:: The default
01661  * Zlib::SYNC_FLUSH:: Flushes the output to a byte boundary
01662  * Zlib::FULL_FLUSH:: SYNC_FLUSH + resets the compression state
01663  * Zlib::FINISH:: Pending input is processed, pending output is flushed.
01664  *
01665  * See the constants for further description.
01666  *
01667  */
01668 static VALUE
01669 rb_deflate_deflate(int argc, VALUE *argv, VALUE obj)
01670 {
01671     struct zstream *z = get_zstream(obj);
01672     VALUE src, flush;
01673 
01674     rb_scan_args(argc, argv, "11", &src, &flush);
01675     OBJ_INFECT(obj, src);
01676     do_deflate(z, src, ARG_FLUSH(flush));
01677 
01678     return zstream_detach_buffer(z);
01679 }
01680 
01681 /*
01682  * Document-method: Zlib::Deflate#<<
01683  *
01684  * call-seq: << string
01685  *
01686  * Inputs +string+ into the deflate stream just like Zlib::Deflate#deflate, but
01687  * returns the Zlib::Deflate object itself.  The output from the stream is
01688  * preserved in output buffer.
01689  */
01690 static VALUE
01691 rb_deflate_addstr(VALUE obj, VALUE src)
01692 {
01693     OBJ_INFECT(obj, src);
01694     do_deflate(get_zstream(obj), src, Z_NO_FLUSH);
01695     return obj;
01696 }
01697 
01698 /*
01699  * Document-method: Zlib::Deflate#flush
01700  *
01701  * call-seq:
01702  *   flush(flush = Zlib::SYNC_FLUSH)                 -> String
01703  *   flush(flush = Zlib::SYNC_FLUSH) { |chunk| ... } -> nil
01704  *
01705  * This method is equivalent to <tt>deflate('', flush)</tt>. This method is
01706  * just provided to improve the readability of your Ruby program.  If a block
01707  * is given chunks of deflate output are yielded to the block until the buffer
01708  * is flushed.
01709  *
01710  * See Zlib::Deflate#deflate for detail on the +flush+ constants NO_FLUSH,
01711  * SYNC_FLUSH, FULL_FLUSH and FINISH.
01712  */
01713 static VALUE
01714 rb_deflate_flush(int argc, VALUE *argv, VALUE obj)
01715 {
01716     struct zstream *z = get_zstream(obj);
01717     VALUE v_flush;
01718     int flush;
01719 
01720     rb_scan_args(argc, argv, "01", &v_flush);
01721     flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
01722     if (flush != Z_NO_FLUSH) {  /* prevent Z_BUF_ERROR */
01723         zstream_run(z, (Bytef*)"", 0, flush);
01724     }
01725 
01726     return zstream_detach_buffer(z);
01727 }
01728 
01729 /*
01730  * Document-method: Zlib::Deflate.params
01731  *
01732  * call-seq: params(level, strategy)
01733  *
01734  * Changes the parameters of the deflate stream to allow changes between
01735  * different types of data that require different types of compression.  Any
01736  * unprocessed data is flushed before changing the params.
01737  *
01738  * See Zlib::Deflate.new for a description of +level+ and +strategy+.
01739  *
01740  */
01741 static VALUE
01742 rb_deflate_params(VALUE obj, VALUE v_level, VALUE v_strategy)
01743 {
01744     struct zstream *z = get_zstream(obj);
01745     int level, strategy;
01746     int err;
01747     uInt n;
01748 
01749     level = ARG_LEVEL(v_level);
01750     strategy = ARG_STRATEGY(v_strategy);
01751 
01752     n = z->stream.avail_out;
01753     err = deflateParams(&z->stream, level, strategy);
01754     z->buf_filled += n - z->stream.avail_out;
01755     while (err == Z_BUF_ERROR) {
01756         rb_warning("deflateParams() returned Z_BUF_ERROR");
01757         zstream_expand_buffer(z);
01758         n = z->stream.avail_out;
01759         err = deflateParams(&z->stream, level, strategy);
01760         z->buf_filled += n - z->stream.avail_out;
01761     }
01762     if (err != Z_OK) {
01763         raise_zlib_error(err, z->stream.msg);
01764     }
01765 
01766     return Qnil;
01767 }
01768 
01769 /*
01770  * Document-method: Zlib::Deflate.set_dictionary
01771  *
01772  * call-seq: set_dictionary(string)
01773  *
01774  * Sets the preset dictionary and returns +string+. This method is available
01775  * just only after Zlib::Deflate.new or Zlib::ZStream#reset method was called.
01776  * See zlib.h for details.
01777  *
01778  * Can raise errors of Z_STREAM_ERROR if a parameter is invalid (such as
01779  * NULL dictionary) or the stream state is inconsistent, Z_DATA_ERROR if
01780  * the given dictionary doesn't match the expected one (incorrect adler32 value)
01781  *
01782  */
01783 static VALUE
01784 rb_deflate_set_dictionary(VALUE obj, VALUE dic)
01785 {
01786     struct zstream *z = get_zstream(obj);
01787     VALUE src = dic;
01788     int err;
01789 
01790     OBJ_INFECT(obj, dic);
01791     StringValue(src);
01792     err = deflateSetDictionary(&z->stream,
01793                                (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
01794     if (err != Z_OK) {
01795         raise_zlib_error(err, z->stream.msg);
01796     }
01797 
01798     return dic;
01799 }
01800 
01801 
01802 /* ------------------------------------------------------------------------- */
01803 
01804 /*
01805  * Document-class: Zlib::Inflate
01806  *
01807  * Zlib:Inflate is the class for decompressing compressed data.  Unlike
01808  * Zlib::Deflate, an instance of this class is not able to duplicate (clone,
01809  * dup) itself.
01810  */
01811 
01812 static VALUE
01813 rb_inflate_s_allocate(VALUE klass)
01814 {
01815     VALUE inflate = zstream_inflate_new(klass);
01816     rb_ivar_set(inflate, id_dictionaries, rb_hash_new());
01817     return inflate;
01818 }
01819 
01820 /*
01821  * Document-method: Zlib::Inflate.new
01822  *
01823  * call-seq:
01824  *   Zlib::Inflate.new(window_bits = Zlib::MAX_WBITS)
01825  *
01826  * Creates a new inflate stream for decompression.  +window_bits+ sets the
01827  * size of the history buffer and can have the following values:
01828  *
01829  * 0::
01830  *   Have inflate use the window size from the zlib header of the compressed
01831  *   stream.
01832  *
01833  * (8..15)
01834  *   Overrides the window size of the inflate header in the compressed stream.
01835  *   The window size must be greater than or equal to the window size of the
01836  *   compressed stream.
01837  *
01838  * Greater than 15::
01839  *   Add 32 to window_bits to enable zlib and gzip decoding with automatic
01840  *   header detection, or add 16 to decode only the gzip format (a
01841  *   Zlib::DataError will be raised for a non-gzip stream).
01842  *
01843  * (-8..-15)::
01844  *   Enables raw deflate mode which will not generate a check value, and will
01845  *   not look for any check values for comparison at the end of the stream.
01846  *
01847  *   This is for use with other formats that use the deflate compressed data
01848  *   format such as zip which provide their own check values.
01849  *
01850  * == Example
01851  *
01852  *   open "compressed.file" do |compressed_io|
01853  *     inflate = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
01854  *
01855  *     begin
01856  *       open "uncompressed.file", "w+" do |uncompressed_io|
01857  *         uncompressed_io << zi.inflate(compressed_io.read)
01858  *       }
01859  *     ensure
01860  *       zi.close
01861  *     end
01862  *   end
01863  *
01864  */
01865 static VALUE
01866 rb_inflate_initialize(int argc, VALUE *argv, VALUE obj)
01867 {
01868     struct zstream *z;
01869     VALUE wbits;
01870     int err;
01871 
01872     rb_scan_args(argc, argv, "01", &wbits);
01873     Data_Get_Struct(obj, struct zstream, z);
01874 
01875     err = inflateInit2(&z->stream, ARG_WBITS(wbits));
01876     if (err != Z_OK) {
01877         raise_zlib_error(err, z->stream.msg);
01878     }
01879     ZSTREAM_READY(z);
01880 
01881     return obj;
01882 }
01883 
01884 static VALUE
01885 inflate_run(VALUE args)
01886 {
01887     struct zstream *z = (struct zstream*)((VALUE*)args)[0];
01888     VALUE src = ((VALUE*)args)[1];
01889 
01890     zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_SYNC_FLUSH);
01891     zstream_run(z, (Bytef*)"", 0, Z_FINISH);  /* for checking errors */
01892     return zstream_detach_buffer(z);
01893 }
01894 
01895 /*
01896  * Document-method: Zlib::inflate
01897  *
01898  * call-seq:
01899  *   Zlib.inflate(string)
01900  *   Zlib::Inflate.inflate(string)
01901  *
01902  * Decompresses +string+. Raises a Zlib::NeedDict exception if a preset
01903  * dictionary is needed for decompression.
01904  *
01905  * This method is almost equivalent to the following code:
01906  *
01907  *   def inflate(string)
01908  *     zstream = Zlib::Inflate.new
01909  *     buf = zstream.inflate(string)
01910  *     zstream.finish
01911  *     zstream.close
01912  *     buf
01913  *   end
01914  *
01915  * See also Zlib.deflate
01916  *
01917  */
01918 static VALUE
01919 rb_inflate_s_inflate(VALUE obj, VALUE src)
01920 {
01921     struct zstream z;
01922     VALUE dst, args[2];
01923     int err;
01924 
01925     StringValue(src);
01926     zstream_init_inflate(&z);
01927     err = inflateInit(&z.stream);
01928     if (err != Z_OK) {
01929         raise_zlib_error(err, z.stream.msg);
01930     }
01931     ZSTREAM_READY(&z);
01932 
01933     args[0] = (VALUE)&z;
01934     args[1] = src;
01935     dst = rb_ensure(inflate_run, (VALUE)args, zstream_end, (VALUE)&z);
01936 
01937     OBJ_INFECT(dst, src);
01938     return dst;
01939 }
01940 
01941 static void
01942 do_inflate(struct zstream *z, VALUE src)
01943 {
01944     if (NIL_P(src)) {
01945         zstream_run(z, (Bytef*)"", 0, Z_FINISH);
01946         return;
01947     }
01948     StringValue(src);
01949     if (RSTRING_LEN(src) > 0 || z->stream.avail_in > 0) { /* prevent Z_BUF_ERROR */
01950         zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_SYNC_FLUSH);
01951     }
01952 }
01953 
01954 /* Document-method: Zlib::Inflate#add_dictionary
01955  *
01956  * call-seq: add_dictionary(string)
01957  *
01958  * Provide the inflate stream with a dictionary that may be required in the
01959  * future.  Multiple dictionaries may be provided.  The inflate stream will
01960  * automatically choose the correct user-provided dictionary based on the
01961  * stream's required dictionary.
01962  */
01963 static VALUE
01964 rb_inflate_add_dictionary(VALUE obj, VALUE dictionary) {
01965     VALUE dictionaries = rb_ivar_get(obj, id_dictionaries);
01966     VALUE checksum = do_checksum(1, &dictionary, adler32);
01967 
01968     rb_hash_aset(dictionaries, checksum, dictionary);
01969 
01970     return obj;
01971 }
01972 
01973 /*
01974  * Document-method: Zlib::Inflate#inflate
01975  *
01976  * call-seq:
01977  *   inflate(deflate_string)                 -> String
01978  *   inflate(deflate_string) { |chunk| ... } -> nil
01979  *
01980  * Inputs +deflate_string+ into the inflate stream and returns the output from
01981  * the stream.  Calling this method, both the input and the output buffer of
01982  * the stream are flushed.  If string is +nil+, this method finishes the
01983  * stream, just like Zlib::ZStream#finish.
01984  *
01985  * If a block is given consecutive inflated chunks from the +deflate_string+
01986  * are yielded to the block and +nil+ is returned.
01987  *
01988  * Raises a Zlib::NeedDict exception if a preset dictionary is needed to
01989  * decompress.  Set the dictionary by Zlib::Inflate#set_dictionary and then
01990  * call this method again with an empty string to flush the stream:
01991  *
01992  *   inflater = Zlib::Inflate.new
01993  *
01994  *   begin
01995  *     out = inflater.inflate compressed
01996  *   rescue Zlib::NeedDict
01997  *     # ensure the dictionary matches the stream's required dictionary
01998  *     raise unless inflater.adler == Zlib.adler32(dictionary)
01999  *
02000  *     inflater.set_dictionary dictionary
02001  *     inflater.inflate ''
02002  *   end
02003  *
02004  *   # ...
02005  *
02006  *   inflater.close
02007  *
02008  * See also Zlib::Inflate.new
02009  */
02010 static VALUE
02011 rb_inflate_inflate(VALUE obj, VALUE src)
02012 {
02013     struct zstream *z = get_zstream(obj);
02014     VALUE dst;
02015 
02016     OBJ_INFECT(obj, src);
02017 
02018     if (ZSTREAM_IS_FINISHED(z)) {
02019         if (NIL_P(src)) {
02020             dst = zstream_detach_buffer(z);
02021         }
02022         else {
02023             StringValue(src);
02024             zstream_append_buffer2(z, src);
02025             dst = rb_str_new(0, 0);
02026             OBJ_INFECT(dst, obj);
02027         }
02028     }
02029     else {
02030         do_inflate(z, src);
02031         dst = zstream_detach_buffer(z);
02032         if (ZSTREAM_IS_FINISHED(z)) {
02033             zstream_passthrough_input(z);
02034         }
02035     }
02036 
02037     return dst;
02038 }
02039 
02040 /*
02041  * call-seq: << string
02042  *
02043  * Inputs +string+ into the inflate stream just like Zlib::Inflate#inflate, but
02044  * returns the Zlib::Inflate object itself.  The output from the stream is
02045  * preserved in output buffer.
02046  */
02047 static VALUE
02048 rb_inflate_addstr(VALUE obj, VALUE src)
02049 {
02050     struct zstream *z = get_zstream(obj);
02051 
02052     OBJ_INFECT(obj, src);
02053 
02054     if (ZSTREAM_IS_FINISHED(z)) {
02055         if (!NIL_P(src)) {
02056             StringValue(src);
02057             zstream_append_buffer2(z, src);
02058         }
02059     }
02060     else {
02061         do_inflate(z, src);
02062         if (ZSTREAM_IS_FINISHED(z)) {
02063             zstream_passthrough_input(z);
02064         }
02065     }
02066 
02067     return obj;
02068 }
02069 
02070 /*
02071  * call-seq: sync(string)
02072  *
02073  * Inputs +string+ into the end of input buffer and skips data until a full
02074  * flush point can be found.  If the point is found in the buffer, this method
02075  * flushes the buffer and returns false.  Otherwise it returns +true+ and the
02076  * following data of full flush point is preserved in the buffer.
02077  */
02078 static VALUE
02079 rb_inflate_sync(VALUE obj, VALUE src)
02080 {
02081     struct zstream *z = get_zstream(obj);
02082 
02083     OBJ_INFECT(obj, src);
02084     StringValue(src);
02085     return zstream_sync(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src));
02086 }
02087 
02088 /*
02089  * Quoted verbatim from original documentation:
02090  *
02091  *   What is this?
02092  *
02093  * <tt>:)</tt>
02094  */
02095 static VALUE
02096 rb_inflate_sync_point_p(VALUE obj)
02097 {
02098     struct zstream *z = get_zstream(obj);
02099     int err;
02100 
02101     err = inflateSyncPoint(&z->stream);
02102     if (err == 1) {
02103         return Qtrue;
02104     }
02105     if (err != Z_OK) {
02106         raise_zlib_error(err, z->stream.msg);
02107     }
02108     return Qfalse;
02109 }
02110 
02111 /*
02112  * Document-method: Zlib::Inflate#set_dictionary
02113  *
02114  * Sets the preset dictionary and returns +string+.  This method is available just
02115  * only after a Zlib::NeedDict exception was raised.  See zlib.h for details.
02116  *
02117  */
02118 static VALUE
02119 rb_inflate_set_dictionary(VALUE obj, VALUE dic)
02120 {
02121     struct zstream *z = get_zstream(obj);
02122     VALUE src = dic;
02123     int err;
02124 
02125     OBJ_INFECT(obj, dic);
02126     StringValue(src);
02127     err = inflateSetDictionary(&z->stream,
02128                                (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
02129     if (err != Z_OK) {
02130         raise_zlib_error(err, z->stream.msg);
02131     }
02132 
02133     return dic;
02134 }
02135 
02136 
02137 
02138 #if GZIP_SUPPORT
02139 
02140 /* NOTE: Features for gzip files of Ruby/zlib are written from scratch
02141  *       and using undocumented feature of zlib, negative wbits.
02142  *       I don't think gzFile APIs of zlib are good for Ruby.
02143  */
02144 
02145 /*------- .gz file header --------*/
02146 
02147 #define GZ_MAGIC1             0x1f
02148 #define GZ_MAGIC2             0x8b
02149 #define GZ_METHOD_DEFLATE     8
02150 #define GZ_FLAG_MULTIPART     0x2
02151 #define GZ_FLAG_EXTRA         0x4
02152 #define GZ_FLAG_ORIG_NAME     0x8
02153 #define GZ_FLAG_COMMENT       0x10
02154 #define GZ_FLAG_ENCRYPT       0x20
02155 #define GZ_FLAG_UNKNOWN_MASK  0xc0
02156 
02157 #define GZ_EXTRAFLAG_FAST     0x4
02158 #define GZ_EXTRAFLAG_SLOW     0x2
02159 
02160 /* from zutil.h */
02161 #define OS_MSDOS    0x00
02162 #define OS_AMIGA    0x01
02163 #define OS_VMS      0x02
02164 #define OS_UNIX     0x03
02165 #define OS_ATARI    0x05
02166 #define OS_OS2      0x06
02167 #define OS_MACOS    0x07
02168 #define OS_TOPS20   0x0a
02169 #define OS_WIN32    0x0b
02170 
02171 #define OS_VMCMS    0x04
02172 #define OS_ZSYSTEM  0x08
02173 #define OS_CPM      0x09
02174 #define OS_QDOS     0x0c
02175 #define OS_RISCOS   0x0d
02176 #define OS_UNKNOWN  0xff
02177 
02178 #ifndef OS_CODE
02179 #define OS_CODE  OS_UNIX
02180 #endif
02181 
02182 static ID id_write, id_read, id_readpartial, id_flush, id_seek, id_close, id_path, id_input;
02183 static VALUE cGzError, cNoFooter, cCRCError, cLengthError;
02184 
02185 
02186 
02187 /*-------- gzfile internal APIs --------*/
02188 
02189 struct gzfile {
02190     struct zstream z;
02191     VALUE io;
02192     int level;
02193     time_t mtime;       /* for header */
02194     int os_code;        /* for header */
02195     VALUE orig_name;    /* for header; must be a String */
02196     VALUE comment;      /* for header; must be a String */
02197     unsigned long crc;
02198     int lineno;
02199     long ungetc;
02200     void (*end)(struct gzfile *);
02201     rb_encoding *enc;
02202     rb_encoding *enc2;
02203     rb_econv_t *ec;
02204     int ecflags;
02205     VALUE ecopts;
02206     char *cbuf;
02207     VALUE path;
02208 };
02209 #define GZFILE_CBUF_CAPA 10
02210 
02211 #define GZFILE_FLAG_SYNC             ZSTREAM_FLAG_UNUSED
02212 #define GZFILE_FLAG_HEADER_FINISHED  (ZSTREAM_FLAG_UNUSED << 1)
02213 #define GZFILE_FLAG_FOOTER_FINISHED  (ZSTREAM_FLAG_UNUSED << 2)
02214 
02215 #define GZFILE_IS_FINISHED(gz) \
02216     (ZSTREAM_IS_FINISHED(&(gz)->z) && (gz)->z.buf_filled == 0)
02217 
02218 #define GZFILE_READ_SIZE  2048
02219 
02220 
02221 static void
02222 gzfile_mark(struct gzfile *gz)
02223 {
02224     rb_gc_mark(gz->io);
02225     rb_gc_mark(gz->orig_name);
02226     rb_gc_mark(gz->comment);
02227     zstream_mark(&gz->z);
02228     rb_gc_mark(gz->ecopts);
02229     rb_gc_mark(gz->path);
02230 }
02231 
02232 static void
02233 gzfile_free(struct gzfile *gz)
02234 {
02235     struct zstream *z = &gz->z;
02236 
02237     if (ZSTREAM_IS_READY(z)) {
02238         if (z->func == &deflate_funcs) {
02239             finalizer_warn("Zlib::GzipWriter object must be closed explicitly.");
02240         }
02241         zstream_finalize(z);
02242     }
02243     if (gz->cbuf) {
02244         xfree(gz->cbuf);
02245     }
02246     xfree(gz);
02247 }
02248 
02249 static VALUE
02250 gzfile_new(klass, funcs, endfunc)
02251     VALUE klass;
02252     const struct zstream_funcs *funcs;
02253     void (*endfunc)(struct gzfile *);
02254 {
02255     VALUE obj;
02256     struct gzfile *gz;
02257 
02258     obj = Data_Make_Struct(klass, struct gzfile, gzfile_mark, gzfile_free, gz);
02259     zstream_init(&gz->z, funcs);
02260     gz->z.flags |= ZSTREAM_FLAG_GZFILE;
02261     gz->io = Qnil;
02262     gz->level = 0;
02263     gz->mtime = 0;
02264     gz->os_code = OS_CODE;
02265     gz->orig_name = Qnil;
02266     gz->comment = Qnil;
02267     gz->crc = crc32(0, Z_NULL, 0);
02268     gz->lineno = 0;
02269     gz->ungetc = 0;
02270     gz->end = endfunc;
02271     gz->enc = rb_default_external_encoding();
02272     gz->enc2 = 0;
02273     gz->ec = NULL;
02274     gz->ecflags = 0;
02275     gz->ecopts = Qnil;
02276     gz->cbuf = 0;
02277     gz->path = Qnil;
02278 
02279     return obj;
02280 }
02281 
02282 #define gzfile_writer_new(gz) gzfile_new((gz),&deflate_funcs,gzfile_writer_end)
02283 #define gzfile_reader_new(gz) gzfile_new((gz),&inflate_funcs,gzfile_reader_end)
02284 
02285 static void
02286 gzfile_reset(struct gzfile *gz)
02287 {
02288     zstream_reset(&gz->z);
02289     gz->crc = crc32(0, Z_NULL, 0);
02290     gz->lineno = 0;
02291     gz->ungetc = 0;
02292     if (gz->ec) {
02293         rb_econv_close(gz->ec);
02294         gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
02295                                     gz->ecflags, gz->ecopts);
02296     }
02297 }
02298 
02299 static void
02300 gzfile_close(struct gzfile *gz, int closeflag)
02301 {
02302     VALUE io = gz->io;
02303 
02304     gz->end(gz);
02305     gz->io = Qnil;
02306     gz->orig_name = Qnil;
02307     gz->comment = Qnil;
02308     if (closeflag && rb_respond_to(io, id_close)) {
02309         rb_funcall(io, id_close, 0);
02310     }
02311 }
02312 
02313 static void
02314 gzfile_write_raw(struct gzfile *gz)
02315 {
02316     VALUE str;
02317 
02318     if (gz->z.buf_filled > 0) {
02319         str = zstream_detach_buffer(&gz->z);
02320         OBJ_TAINT(str);  /* for safe */
02321         rb_funcall(gz->io, id_write, 1, str);
02322         if ((gz->z.flags & GZFILE_FLAG_SYNC)
02323             && rb_respond_to(gz->io, id_flush))
02324             rb_funcall(gz->io, id_flush, 0);
02325     }
02326 }
02327 
02328 static VALUE
02329 gzfile_read_raw_partial(VALUE arg)
02330 {
02331     struct gzfile *gz = (struct gzfile*)arg;
02332     VALUE str;
02333 
02334     str = rb_funcall(gz->io, id_readpartial, 1, INT2FIX(GZFILE_READ_SIZE));
02335     Check_Type(str, T_STRING);
02336     return str;
02337 }
02338 
02339 static VALUE
02340 gzfile_read_raw_rescue(VALUE arg)
02341 {
02342     struct gzfile *gz = (struct gzfile*)arg;
02343     VALUE str = Qnil;
02344     if (rb_obj_is_kind_of(rb_errinfo(), rb_eNoMethodError)) {
02345         str = rb_funcall(gz->io, id_read, 1, INT2FIX(GZFILE_READ_SIZE));
02346         if (!NIL_P(str)) {
02347             Check_Type(str, T_STRING);
02348         }
02349     }
02350     return str; /* return nil when EOFError */
02351 }
02352 
02353 static VALUE
02354 gzfile_read_raw(struct gzfile *gz)
02355 {
02356     return rb_rescue2(gzfile_read_raw_partial, (VALUE)gz,
02357                       gzfile_read_raw_rescue, (VALUE)gz,
02358                       rb_eEOFError, rb_eNoMethodError, (VALUE)0);
02359 }
02360 
02361 static int
02362 gzfile_read_raw_ensure(struct gzfile *gz, long size)
02363 {
02364     VALUE str;
02365 
02366     while (NIL_P(gz->z.input) || RSTRING_LEN(gz->z.input) < size) {
02367         str = gzfile_read_raw(gz);
02368         if (NIL_P(str)) return 0;
02369         zstream_append_input2(&gz->z, str);
02370     }
02371     return 1;
02372 }
02373 
02374 static char *
02375 gzfile_read_raw_until_zero(struct gzfile *gz, long offset)
02376 {
02377     VALUE str;
02378     char *p;
02379 
02380     for (;;) {
02381         p = memchr(RSTRING_PTR(gz->z.input) + offset, '\0',
02382                    RSTRING_LEN(gz->z.input) - offset);
02383         if (p) break;
02384         str = gzfile_read_raw(gz);
02385         if (NIL_P(str)) {
02386             rb_raise(cGzError, "unexpected end of file");
02387         }
02388         offset = RSTRING_LEN(gz->z.input);
02389         zstream_append_input2(&gz->z, str);
02390     }
02391     return p;
02392 }
02393 
02394 static unsigned int
02395 gzfile_get16(const unsigned char *src)
02396 {
02397     unsigned int n;
02398     n  = *(src++) & 0xff;
02399     n |= (*(src++) & 0xff) << 8;
02400     return n;
02401 }
02402 
02403 static unsigned long
02404 gzfile_get32(const unsigned char *src)
02405 {
02406     unsigned long n;
02407     n  = *(src++) & 0xff;
02408     n |= (*(src++) & 0xff) << 8;
02409     n |= (*(src++) & 0xff) << 16;
02410     n |= (*(src++) & 0xffU) << 24;
02411     return n;
02412 }
02413 
02414 static void
02415 gzfile_set32(unsigned long n, unsigned char *dst)
02416 {
02417     *(dst++) = n & 0xff;
02418     *(dst++) = (n >> 8) & 0xff;
02419     *(dst++) = (n >> 16) & 0xff;
02420     *dst     = (n >> 24) & 0xff;
02421 }
02422 
02423 static void
02424 gzfile_raise(struct gzfile *gz, VALUE klass, const char *message)
02425 {
02426     VALUE exc = rb_exc_new2(klass, message);
02427     if (!NIL_P(gz->z.input)) {
02428         rb_ivar_set(exc, id_input, rb_str_resurrect(gz->z.input));
02429     }
02430     rb_exc_raise(exc);
02431 }
02432 
02433 /*
02434  * Document-method: Zlib::GzipFile::Error#inspect
02435  *
02436  * Constructs a String of the GzipFile Error
02437  */
02438 static VALUE
02439 gzfile_error_inspect(VALUE error)
02440 {
02441     VALUE str = rb_call_super(0, 0);
02442     VALUE input = rb_attr_get(error, id_input);
02443 
02444     if (!NIL_P(input)) {
02445         rb_str_resize(str, RSTRING_LEN(str)-1);
02446         rb_str_cat2(str, ", input=");
02447         rb_str_append(str, rb_str_inspect(input));
02448         rb_str_cat2(str, ">");
02449     }
02450     return str;
02451 }
02452 
02453 static void
02454 gzfile_make_header(struct gzfile *gz)
02455 {
02456     Bytef buf[10];  /* the size of gzip header */
02457     unsigned char flags = 0, extraflags = 0;
02458 
02459     if (!NIL_P(gz->orig_name)) {
02460         flags |= GZ_FLAG_ORIG_NAME;
02461     }
02462     if (!NIL_P(gz->comment)) {
02463         flags |= GZ_FLAG_COMMENT;
02464     }
02465     if (gz->mtime == 0) {
02466         gz->mtime = time(0);
02467     }
02468 
02469     if (gz->level == Z_BEST_SPEED) {
02470         extraflags |= GZ_EXTRAFLAG_FAST;
02471     }
02472     else if (gz->level == Z_BEST_COMPRESSION) {
02473         extraflags |= GZ_EXTRAFLAG_SLOW;
02474     }
02475 
02476     buf[0] = GZ_MAGIC1;
02477     buf[1] = GZ_MAGIC2;
02478     buf[2] = GZ_METHOD_DEFLATE;
02479     buf[3] = flags;
02480     gzfile_set32((unsigned long)gz->mtime, &buf[4]);
02481     buf[8] = extraflags;
02482     buf[9] = gz->os_code;
02483     zstream_append_buffer(&gz->z, buf, sizeof(buf));
02484 
02485     if (!NIL_P(gz->orig_name)) {
02486         zstream_append_buffer2(&gz->z, gz->orig_name);
02487         zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
02488     }
02489     if (!NIL_P(gz->comment)) {
02490         zstream_append_buffer2(&gz->z, gz->comment);
02491         zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
02492     }
02493 
02494     gz->z.flags |= GZFILE_FLAG_HEADER_FINISHED;
02495 }
02496 
02497 static void
02498 gzfile_make_footer(struct gzfile *gz)
02499 {
02500     Bytef buf[8];  /* 8 is the size of gzip footer */
02501 
02502     gzfile_set32(gz->crc, buf);
02503     gzfile_set32(gz->z.stream.total_in, &buf[4]);
02504     zstream_append_buffer(&gz->z, buf, sizeof(buf));
02505     gz->z.flags |= GZFILE_FLAG_FOOTER_FINISHED;
02506 }
02507 
02508 static void
02509 gzfile_read_header(struct gzfile *gz)
02510 {
02511     const unsigned char *head;
02512     long len;
02513     char flags, *p;
02514 
02515     if (!gzfile_read_raw_ensure(gz, 10)) {  /* 10 is the size of gzip header */
02516         gzfile_raise(gz, cGzError, "not in gzip format");
02517     }
02518 
02519     head = (unsigned char*)RSTRING_PTR(gz->z.input);
02520 
02521     if (head[0] != GZ_MAGIC1 || head[1] != GZ_MAGIC2) {
02522         gzfile_raise(gz, cGzError, "not in gzip format");
02523     }
02524     if (head[2] != GZ_METHOD_DEFLATE) {
02525         rb_raise(cGzError, "unsupported compression method %d", head[2]);
02526     }
02527 
02528     flags = head[3];
02529     if (flags & GZ_FLAG_MULTIPART) {
02530         rb_raise(cGzError, "multi-part gzip file is not supported");
02531     }
02532     else if (flags & GZ_FLAG_ENCRYPT) {
02533         rb_raise(cGzError, "encrypted gzip file is not supported");
02534     }
02535     else if (flags & GZ_FLAG_UNKNOWN_MASK) {
02536         rb_raise(cGzError, "unknown flags 0x%02x", flags);
02537     }
02538 
02539     if (head[8] & GZ_EXTRAFLAG_FAST) {
02540         gz->level = Z_BEST_SPEED;
02541     }
02542     else if (head[8] & GZ_EXTRAFLAG_SLOW) {
02543         gz->level = Z_BEST_COMPRESSION;
02544     }
02545     else {
02546         gz->level = Z_DEFAULT_COMPRESSION;
02547     }
02548 
02549     gz->mtime = gzfile_get32(&head[4]);
02550     gz->os_code = head[9];
02551     zstream_discard_input(&gz->z, 10);
02552 
02553     if (flags & GZ_FLAG_EXTRA) {
02554         if (!gzfile_read_raw_ensure(gz, 2)) {
02555             rb_raise(cGzError, "unexpected end of file");
02556         }
02557         len = gzfile_get16((Bytef*)RSTRING_PTR(gz->z.input));
02558         if (!gzfile_read_raw_ensure(gz, 2 + len)) {
02559             rb_raise(cGzError, "unexpected end of file");
02560         }
02561         zstream_discard_input(&gz->z, 2 + len);
02562     }
02563     if (flags & GZ_FLAG_ORIG_NAME) {
02564         if (!gzfile_read_raw_ensure(gz, 1)) {
02565             rb_raise(cGzError, "unexpected end of file");
02566         }
02567         p = gzfile_read_raw_until_zero(gz, 0);
02568         len = p - RSTRING_PTR(gz->z.input);
02569         gz->orig_name = rb_str_new(RSTRING_PTR(gz->z.input), len);
02570         OBJ_TAINT(gz->orig_name);  /* for safe */
02571         zstream_discard_input(&gz->z, len + 1);
02572     }
02573     if (flags & GZ_FLAG_COMMENT) {
02574         if (!gzfile_read_raw_ensure(gz, 1)) {
02575             rb_raise(cGzError, "unexpected end of file");
02576         }
02577         p = gzfile_read_raw_until_zero(gz, 0);
02578         len = p - RSTRING_PTR(gz->z.input);
02579         gz->comment = rb_str_new(RSTRING_PTR(gz->z.input), len);
02580         OBJ_TAINT(gz->comment);  /* for safe */
02581         zstream_discard_input(&gz->z, len + 1);
02582     }
02583 
02584     if (gz->z.input != Qnil && RSTRING_LEN(gz->z.input) > 0) {
02585         zstream_run(&gz->z, 0, 0, Z_SYNC_FLUSH);
02586     }
02587 }
02588 
02589 static void
02590 gzfile_check_footer(struct gzfile *gz)
02591 {
02592     unsigned long crc, length;
02593 
02594     gz->z.flags |= GZFILE_FLAG_FOOTER_FINISHED;
02595 
02596     if (!gzfile_read_raw_ensure(gz, 8)) { /* 8 is the size of gzip footer */
02597         gzfile_raise(gz, cNoFooter, "footer is not found");
02598     }
02599 
02600     crc = gzfile_get32((Bytef*)RSTRING_PTR(gz->z.input));
02601     length = gzfile_get32((Bytef*)RSTRING_PTR(gz->z.input) + 4);
02602 
02603     gz->z.stream.total_in += 8;  /* to rewind correctly */
02604     zstream_discard_input(&gz->z, 8);
02605 
02606     if (gz->crc != crc) {
02607         rb_raise(cCRCError, "invalid compressed data -- crc error");
02608     }
02609     if ((uint32_t)gz->z.stream.total_out != length) {
02610         rb_raise(cLengthError, "invalid compressed data -- length error");
02611     }
02612 }
02613 
02614 static void
02615 gzfile_write(struct gzfile *gz, Bytef *str, long len)
02616 {
02617     if (!(gz->z.flags & GZFILE_FLAG_HEADER_FINISHED)) {
02618         gzfile_make_header(gz);
02619     }
02620 
02621     if (len > 0 || (gz->z.flags & GZFILE_FLAG_SYNC)) {
02622         gz->crc = checksum_long(crc32, gz->crc, str, len);
02623         zstream_run(&gz->z, str, len, (gz->z.flags & GZFILE_FLAG_SYNC)
02624                     ? Z_SYNC_FLUSH : Z_NO_FLUSH);
02625     }
02626     gzfile_write_raw(gz);
02627 }
02628 
02629 static long
02630 gzfile_read_more(struct gzfile *gz)
02631 {
02632     volatile VALUE str;
02633 
02634     while (!ZSTREAM_IS_FINISHED(&gz->z)) {
02635         str = gzfile_read_raw(gz);
02636         if (NIL_P(str)) {
02637             if (!ZSTREAM_IS_FINISHED(&gz->z)) {
02638                 rb_raise(cGzError, "unexpected end of file");
02639             }
02640             break;
02641         }
02642         if (RSTRING_LEN(str) > 0) { /* prevent Z_BUF_ERROR */
02643             zstream_run(&gz->z, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str),
02644                         Z_SYNC_FLUSH);
02645         }
02646         if (gz->z.buf_filled > 0) break;
02647     }
02648     return gz->z.buf_filled;
02649 }
02650 
02651 static void
02652 gzfile_calc_crc(struct gzfile *gz, VALUE str)
02653 {
02654     if (RSTRING_LEN(str) <= gz->ungetc) {
02655         gz->ungetc -= RSTRING_LEN(str);
02656     }
02657     else {
02658         gz->crc = checksum_long(crc32, gz->crc, (Bytef*)RSTRING_PTR(str) + gz->ungetc,
02659                         RSTRING_LEN(str) - gz->ungetc);
02660         gz->ungetc = 0;
02661     }
02662 }
02663 
02664 static VALUE
02665 gzfile_newstr(struct gzfile *gz, VALUE str)
02666 {
02667     if (!gz->enc2) {
02668         rb_enc_associate(str, gz->enc);
02669         OBJ_TAINT(str);  /* for safe */
02670         return str;
02671     }
02672     if (gz->ec && rb_enc_dummy_p(gz->enc2)) {
02673         str = rb_econv_str_convert(gz->ec, str, ECONV_PARTIAL_INPUT);
02674         rb_enc_associate(str, gz->enc);
02675         OBJ_TAINT(str);
02676         return str;
02677     }
02678     return rb_str_conv_enc_opts(str, gz->enc2, gz->enc,
02679                                 gz->ecflags, gz->ecopts);
02680 }
02681 
02682 static long
02683 gzfile_fill(struct gzfile *gz, long len)
02684 {
02685     if (len < 0)
02686         rb_raise(rb_eArgError, "negative length %ld given", len);
02687     if (len == 0)
02688         return 0;
02689     while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled < len) {
02690         gzfile_read_more(gz);
02691     }
02692     if (GZFILE_IS_FINISHED(gz)) {
02693         if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
02694             gzfile_check_footer(gz);
02695         }
02696         return -1;
02697     }
02698     return len < gz->z.buf_filled ? len : gz->z.buf_filled;
02699 }
02700 
02701 static VALUE
02702 gzfile_read(struct gzfile *gz, long len)
02703 {
02704     VALUE dst;
02705 
02706     len = gzfile_fill(gz, len);
02707     if (len == 0) return rb_str_new(0, 0);
02708     if (len < 0) return Qnil;
02709     dst = zstream_shift_buffer(&gz->z, len);
02710     if (!NIL_P(dst)) gzfile_calc_crc(gz, dst);
02711     return dst;
02712 }
02713 
02714 static VALUE
02715 gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
02716 {
02717     VALUE dst;
02718 
02719     if (len < 0)
02720         rb_raise(rb_eArgError, "negative length %ld given", len);
02721 
02722     if (!NIL_P(outbuf))
02723         OBJ_TAINT(outbuf);
02724 
02725     if (len == 0) {
02726         if (NIL_P(outbuf))
02727             return rb_str_new(0, 0);
02728         else {
02729             rb_str_resize(outbuf, 0);
02730             return outbuf;
02731         }
02732     }
02733     while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled == 0) {
02734         gzfile_read_more(gz);
02735     }
02736     if (GZFILE_IS_FINISHED(gz)) {
02737         if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
02738             gzfile_check_footer(gz);
02739         }
02740         if (!NIL_P(outbuf))
02741             rb_str_resize(outbuf, 0);
02742         rb_raise(rb_eEOFError, "end of file reached");
02743     }
02744 
02745     dst = zstream_shift_buffer(&gz->z, len);
02746     gzfile_calc_crc(gz, dst);
02747 
02748     if (!NIL_P(outbuf)) {
02749         rb_str_resize(outbuf, RSTRING_LEN(dst));
02750         memcpy(RSTRING_PTR(outbuf), RSTRING_PTR(dst), RSTRING_LEN(dst));
02751         dst = outbuf;
02752     }
02753     OBJ_TAINT(dst);  /* for safe */
02754     return dst;
02755 }
02756 
02757 static VALUE
02758 gzfile_read_all(struct gzfile *gz)
02759 {
02760     VALUE dst;
02761 
02762     while (!ZSTREAM_IS_FINISHED(&gz->z)) {
02763         gzfile_read_more(gz);
02764     }
02765     if (GZFILE_IS_FINISHED(gz)) {
02766         if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
02767             gzfile_check_footer(gz);
02768         }
02769         return rb_str_new(0, 0);
02770     }
02771 
02772     dst = zstream_detach_buffer(&gz->z);
02773     if (NIL_P(dst)) return dst;
02774     gzfile_calc_crc(gz, dst);
02775     OBJ_TAINT(dst);
02776     return gzfile_newstr(gz, dst);
02777 }
02778 
02779 static VALUE
02780 gzfile_getc(struct gzfile *gz)
02781 {
02782     VALUE buf, dst = 0;
02783     int len;
02784 
02785     len = rb_enc_mbmaxlen(gz->enc);
02786     while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled < len) {
02787         gzfile_read_more(gz);
02788     }
02789     if (GZFILE_IS_FINISHED(gz)) {
02790         if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
02791             gzfile_check_footer(gz);
02792         }
02793         return Qnil;
02794     }
02795 
02796     if (gz->ec && rb_enc_dummy_p(gz->enc2)) {
02797         const unsigned char *ss, *sp, *se;
02798         unsigned char *ds, *dp, *de;
02799 
02800         if (!gz->cbuf) {
02801             gz->cbuf = ALLOC_N(char, GZFILE_CBUF_CAPA);
02802         }
02803         ss = sp = (const unsigned char*)RSTRING_PTR(gz->z.buf);
02804         se = sp + gz->z.buf_filled;
02805         ds = dp = (unsigned char *)gz->cbuf;
02806         de = (unsigned char *)ds + GZFILE_CBUF_CAPA;
02807         (void)rb_econv_convert(gz->ec, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_AFTER_OUTPUT);
02808         rb_econv_check_error(gz->ec);
02809         dst = zstream_shift_buffer(&gz->z, sp - ss);
02810         gzfile_calc_crc(gz, dst);
02811         dst = rb_str_new(gz->cbuf, dp - ds);
02812         rb_enc_associate(dst, gz->enc);
02813         OBJ_TAINT(dst);
02814         return dst;
02815     }
02816     else {
02817         buf = gz->z.buf;
02818         len = rb_enc_mbclen(RSTRING_PTR(buf), RSTRING_END(buf), gz->enc);
02819         dst = gzfile_read(gz, len);
02820         if (NIL_P(dst)) return dst;
02821         return gzfile_newstr(gz, dst);
02822     }
02823 }
02824 
02825 static void
02826 gzfile_ungets(struct gzfile *gz, const Bytef *b, long len)
02827 {
02828     zstream_buffer_ungets(&gz->z, b, len);
02829     gz->ungetc+=len;
02830 }
02831 
02832 static void
02833 gzfile_ungetbyte(struct gzfile *gz, int c)
02834 {
02835     zstream_buffer_ungetbyte(&gz->z, c);
02836     gz->ungetc++;
02837 }
02838 
02839 static VALUE
02840 gzfile_writer_end_run(VALUE arg)
02841 {
02842     struct gzfile *gz = (struct gzfile *)arg;
02843 
02844     if (!(gz->z.flags & GZFILE_FLAG_HEADER_FINISHED)) {
02845         gzfile_make_header(gz);
02846     }
02847 
02848     zstream_run(&gz->z, (Bytef*)"", 0, Z_FINISH);
02849     gzfile_make_footer(gz);
02850     gzfile_write_raw(gz);
02851 
02852     return Qnil;
02853 }
02854 
02855 static void
02856 gzfile_writer_end(struct gzfile *gz)
02857 {
02858     if (ZSTREAM_IS_CLOSING(&gz->z)) return;
02859     gz->z.flags |= ZSTREAM_FLAG_CLOSING;
02860 
02861     rb_ensure(gzfile_writer_end_run, (VALUE)gz, zstream_end, (VALUE)&gz->z);
02862 }
02863 
02864 static VALUE
02865 gzfile_reader_end_run(VALUE arg)
02866 {
02867     struct gzfile *gz = (struct gzfile *)arg;
02868 
02869     if (GZFILE_IS_FINISHED(gz)
02870         && !(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
02871         gzfile_check_footer(gz);
02872     }
02873 
02874     return Qnil;
02875 }
02876 
02877 static void
02878 gzfile_reader_end(struct gzfile *gz)
02879 {
02880     if (ZSTREAM_IS_CLOSING(&gz->z)) return;
02881     gz->z.flags |= ZSTREAM_FLAG_CLOSING;
02882 
02883     rb_ensure(gzfile_reader_end_run, (VALUE)gz, zstream_end, (VALUE)&gz->z);
02884 }
02885 
02886 static void
02887 gzfile_reader_rewind(struct gzfile *gz)
02888 {
02889     long n;
02890 
02891     n = gz->z.stream.total_in;
02892     if (!NIL_P(gz->z.input)) {
02893         n += RSTRING_LEN(gz->z.input);
02894     }
02895 
02896     rb_funcall(gz->io, id_seek, 2, rb_int2inum(-n), INT2FIX(1));
02897     gzfile_reset(gz);
02898 }
02899 
02900 static VALUE
02901 gzfile_reader_get_unused(struct gzfile *gz)
02902 {
02903     VALUE str;
02904 
02905     if (!ZSTREAM_IS_READY(&gz->z)) return Qnil;
02906     if (!GZFILE_IS_FINISHED(gz)) return Qnil;
02907     if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
02908         gzfile_check_footer(gz);
02909     }
02910     if (NIL_P(gz->z.input)) return Qnil;
02911 
02912     str = rb_str_resurrect(gz->z.input);
02913     OBJ_TAINT(str);  /* for safe */
02914     return str;
02915 }
02916 
02917 static struct gzfile *
02918 get_gzfile(VALUE obj)
02919 {
02920     struct gzfile *gz;
02921 
02922     Data_Get_Struct(obj, struct gzfile, gz);
02923     if (!ZSTREAM_IS_READY(&gz->z)) {
02924         rb_raise(cGzError, "closed gzip stream");
02925     }
02926     return gz;
02927 }
02928 
02929 
02930 /* ------------------------------------------------------------------------- */
02931 
02932 /*
02933  * Document-class: Zlib::GzipFile
02934  *
02935  * Zlib::GzipFile is an abstract class for handling a gzip formatted
02936  * compressed file. The operations are defined in the subclasses,
02937  * Zlib::GzipReader for reading, and Zlib::GzipWriter for writing.
02938  *
02939  * GzipReader should be used by associating an IO, or IO-like, object.
02940  *
02941  * == Method Catalogue
02942  *
02943  * - ::wrap
02944  * - ::open (Zlib::GzipReader::open and Zlib::GzipWriter::open)
02945  * - #close
02946  * - #closed?
02947  * - #comment
02948  * - comment= (Zlib::GzipWriter#comment=)
02949  * - #crc
02950  * - eof? (Zlib::GzipReader#eof?)
02951  * - #finish
02952  * - #level
02953  * - lineno (Zlib::GzipReader#lineno)
02954  * - lineno= (Zlib::GzipReader#lineno=)
02955  * - #mtime
02956  * - mtime= (Zlib::GzipWriter#mtime=)
02957  * - #orig_name
02958  * - orig_name (Zlib::GzipWriter#orig_name=)
02959  * - #os_code
02960  * - path (when the underlying IO supports #path)
02961  * - #sync
02962  * - #sync=
02963  * - #to_io
02964  *
02965  * (due to internal structure, documentation may appear under Zlib::GzipReader
02966  * or Zlib::GzipWriter)
02967  */
02968 
02969 
02970 typedef struct {
02971     int argc;
02972     VALUE *argv;
02973     VALUE klass;
02974 } new_wrap_arg_t;
02975 
02976 static VALUE
02977 new_wrap(VALUE tmp)
02978 {
02979     new_wrap_arg_t *arg = (new_wrap_arg_t *)tmp;
02980     return rb_class_new_instance(arg->argc, arg->argv, arg->klass);
02981 }
02982 
02983 static VALUE
02984 gzfile_ensure_close(VALUE obj)
02985 {
02986     struct gzfile *gz;
02987 
02988     Data_Get_Struct(obj, struct gzfile, gz);
02989     if (ZSTREAM_IS_READY(&gz->z)) {
02990         gzfile_close(gz, 1);
02991     }
02992     return Qnil;
02993 }
02994 
02995 static VALUE
02996 gzfile_wrap(int argc, VALUE *argv, VALUE klass, int close_io_on_error)
02997 {
02998     VALUE obj;
02999 
03000     if (close_io_on_error) {
03001         int state = 0;
03002         new_wrap_arg_t arg;
03003         arg.argc = argc;
03004         arg.argv = argv;
03005         arg.klass = klass;
03006         obj = rb_protect(new_wrap, (VALUE)&arg, &state);
03007         if (state) {
03008             rb_io_close(argv[0]);
03009             rb_jump_tag(state);
03010         }
03011     }
03012     else {
03013         obj = rb_class_new_instance(argc, argv, klass);
03014     }
03015 
03016     if (rb_block_given_p()) {
03017         return rb_ensure(rb_yield, obj, gzfile_ensure_close, obj);
03018     }
03019     else {
03020         return obj;
03021     }
03022 }
03023 
03024 /*
03025  * Document-method: Zlib::GzipFile.wrap
03026  *
03027  * call-seq:
03028  *   Zlib::GzipReader.wrap(io, ...) { |gz| ... }
03029  *   Zlib::GzipWriter.wrap(io, ...) { |gz| ... }
03030  *
03031  * Creates a GzipReader or GzipWriter associated with +io+, passing in any
03032  * necessary extra options, and executes the block with the newly created
03033  * object just like File.open.
03034  *
03035  * The GzipFile object will be closed automatically after executing the block.
03036  * If you want to keep the associated IO object open, you may call
03037  * Zlib::GzipFile#finish method in the block.
03038  */
03039 static VALUE
03040 rb_gzfile_s_wrap(int argc, VALUE *argv, VALUE klass)
03041 {
03042     return gzfile_wrap(argc, argv, klass, 0);
03043 }
03044 
03045 /*
03046  * Document-method: Zlib::GzipFile.open
03047  *
03048  * See Zlib::GzipReader#open and Zlib::GzipWriter#open.
03049  */
03050 static VALUE
03051 gzfile_s_open(int argc, VALUE *argv, VALUE klass, const char *mode)
03052 {
03053     VALUE io, filename;
03054 
03055     if (argc < 1) {
03056         rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
03057     }
03058     filename = argv[0];
03059     io = rb_file_open_str(filename, mode);
03060     argv[0] = io;
03061     return gzfile_wrap(argc, argv, klass, 1);
03062 }
03063 
03064 /*
03065  * Document-method: Zlib::GzipFile#to_io
03066  *
03067  * Same as IO.
03068  */
03069 static VALUE
03070 rb_gzfile_to_io(VALUE obj)
03071 {
03072     return get_gzfile(obj)->io;
03073 }
03074 
03075 /*
03076  * Document-method: Zlib::GzipFile#crc
03077  *
03078  * Returns CRC value of the uncompressed data.
03079  */
03080 static VALUE
03081 rb_gzfile_crc(VALUE obj)
03082 {
03083     return rb_uint2inum(get_gzfile(obj)->crc);
03084 }
03085 
03086 /*
03087  * Document-method: Zlib::GzipFile#mtime
03088  *
03089  * Returns last modification time recorded in the gzip file header.
03090  */
03091 static VALUE
03092 rb_gzfile_mtime(VALUE obj)
03093 {
03094     return rb_time_new(get_gzfile(obj)->mtime, (time_t)0);
03095 }
03096 
03097 /*
03098  * Document-method: Zlib::GzipFile#level
03099  *
03100  * Returns compression level.
03101  */
03102 static VALUE
03103 rb_gzfile_level(VALUE obj)
03104 {
03105     return INT2FIX(get_gzfile(obj)->level);
03106 }
03107 
03108 /*
03109  * Document-method: Zlib::GzipFile#os_code
03110  *
03111  * Returns OS code number recorded in the gzip file header.
03112  */
03113 static VALUE
03114 rb_gzfile_os_code(VALUE obj)
03115 {
03116     return INT2FIX(get_gzfile(obj)->os_code);
03117 }
03118 
03119 /*
03120  * Document-method: Zlib::GzipFile#orig_name
03121  *
03122  * Returns original filename recorded in the gzip file header, or +nil+ if
03123  * original filename is not present.
03124  */
03125 static VALUE
03126 rb_gzfile_orig_name(VALUE obj)
03127 {
03128     VALUE str = get_gzfile(obj)->orig_name;
03129     if (!NIL_P(str)) {
03130         str = rb_str_dup(str);
03131     }
03132     OBJ_TAINT(str);  /* for safe */
03133     return str;
03134 }
03135 
03136 /*
03137  * Document-method: Zlib::GzipFile#comment
03138  *
03139  * Returns comments recorded in the gzip file header, or nil if the comments
03140  * is not present.
03141  */
03142 static VALUE
03143 rb_gzfile_comment(VALUE obj)
03144 {
03145     VALUE str = get_gzfile(obj)->comment;
03146     if (!NIL_P(str)) {
03147         str = rb_str_dup(str);
03148     }
03149     OBJ_TAINT(str);  /* for safe */
03150     return str;
03151 }
03152 
03153 /*
03154  * Document-method: Zlib::GzipFile#lineno
03155  *
03156  * The line number of the last row read from this file.
03157  */
03158 static VALUE
03159 rb_gzfile_lineno(VALUE obj)
03160 {
03161     return INT2NUM(get_gzfile(obj)->lineno);
03162 }
03163 
03164 /*
03165  * Document-method: Zlib::GzipReader#lineno=
03166  *
03167  * Specify line number of the last row read from this file.
03168  */
03169 static VALUE
03170 rb_gzfile_set_lineno(VALUE obj, VALUE lineno)
03171 {
03172     struct gzfile *gz = get_gzfile(obj);
03173     gz->lineno = NUM2INT(lineno);
03174     return lineno;
03175 }
03176 
03177 /*
03178  * Document-method: Zlib::GzipWriter#mtime=
03179  *
03180  * Specify the modification time (+mtime+) in the gzip header.
03181  * Using a Fixnum or Integer
03182  */
03183 static VALUE
03184 rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
03185 {
03186     struct gzfile *gz = get_gzfile(obj);
03187     VALUE val;
03188 
03189     if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
03190         rb_raise(cGzError, "header is already written");
03191     }
03192 
03193     if (FIXNUM_P(mtime)) {
03194         gz->mtime = FIX2INT(mtime);
03195     }
03196     else {
03197         val = rb_Integer(mtime);
03198         gz->mtime = FIXNUM_P(val) ? FIX2UINT(val) : rb_big2ulong(val);
03199     }
03200     return mtime;
03201 }
03202 
03203 /*
03204  * Document-method: Zlib::GzipFile#orig_name=
03205  *
03206  * Specify the original name (+str+) in the gzip header.
03207  */
03208 static VALUE
03209 rb_gzfile_set_orig_name(VALUE obj, VALUE str)
03210 {
03211     struct gzfile *gz = get_gzfile(obj);
03212     VALUE s;
03213     char *p;
03214 
03215     if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
03216         rb_raise(cGzError, "header is already written");
03217     }
03218     s = rb_str_dup(rb_str_to_str(str));
03219     p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
03220     if (p) {
03221         rb_str_resize(s, p - RSTRING_PTR(s));
03222     }
03223     gz->orig_name = s;
03224     return str;
03225 }
03226 
03227 /*
03228  * Document-method: Zlib::GzipFile#comment=
03229  *
03230  * Specify the comment (+str+) in the gzip header.
03231  */
03232 static VALUE
03233 rb_gzfile_set_comment(VALUE obj, VALUE str)
03234 {
03235     struct gzfile *gz = get_gzfile(obj);
03236     VALUE s;
03237     char *p;
03238 
03239     if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
03240         rb_raise(cGzError, "header is already written");
03241     }
03242     s = rb_str_dup(rb_str_to_str(str));
03243     p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
03244     if (p) {
03245         rb_str_resize(s, p - RSTRING_PTR(s));
03246     }
03247     gz->comment = s;
03248     return str;
03249 }
03250 
03251 /*
03252  * Document-method: Zlib::GzipFile#close
03253  *
03254  * Closes the GzipFile object. This method calls close method of the
03255  * associated IO object. Returns the associated IO object.
03256  */
03257 static VALUE
03258 rb_gzfile_close(VALUE obj)
03259 {
03260     struct gzfile *gz = get_gzfile(obj);
03261     VALUE io;
03262 
03263     io = gz->io;
03264     gzfile_close(gz, 1);
03265     return io;
03266 }
03267 
03268 /*
03269  * Document-method: Zlib::GzipFile#finish
03270  *
03271  * Closes the GzipFile object. Unlike Zlib::GzipFile#close, this method never
03272  * calls the close method of the associated IO object. Returns the associated IO
03273  * object.
03274  */
03275 static VALUE
03276 rb_gzfile_finish(VALUE obj)
03277 {
03278     struct gzfile *gz = get_gzfile(obj);
03279     VALUE io;
03280 
03281     io = gz->io;
03282     gzfile_close(gz, 0);
03283     return io;
03284 }
03285 
03286 /*
03287  * Document-method: Zlib::GzipFile#closed?
03288  *
03289  * Same as IO#closed?
03290  *
03291  */
03292 static VALUE
03293 rb_gzfile_closed_p(VALUE obj)
03294 {
03295     struct gzfile *gz;
03296     Data_Get_Struct(obj, struct gzfile, gz);
03297     return NIL_P(gz->io) ? Qtrue : Qfalse;
03298 }
03299 
03300 /*
03301  * Document-method: Zlib::GzipFile#eof?
03302  *
03303  * Returns +true+ or +false+ whether the stream has reached the end.
03304  */
03305 static VALUE
03306 rb_gzfile_eof_p(VALUE obj)
03307 {
03308     struct gzfile *gz = get_gzfile(obj);
03309     return GZFILE_IS_FINISHED(gz) ? Qtrue : Qfalse;
03310 }
03311 
03312 /*
03313  * Document-method: Zlib::GzipFile#sync
03314  *
03315  * Same as IO#sync
03316  *
03317  */
03318 static VALUE
03319 rb_gzfile_sync(VALUE obj)
03320 {
03321     return (get_gzfile(obj)->z.flags & GZFILE_FLAG_SYNC) ? Qtrue : Qfalse;
03322 }
03323 
03324 /*
03325  * Document-method: Zlib::GzipFile#sync=
03326  *
03327  * call-seq: sync = flag
03328  *
03329  * Same as IO.  If flag is +true+, the associated IO object must respond to the
03330  * +flush+ method.  While +sync+ mode is +true+, the compression ratio
03331  * decreases sharply.
03332  */
03333 static VALUE
03334 rb_gzfile_set_sync(VALUE obj, VALUE mode)
03335 {
03336     struct gzfile *gz = get_gzfile(obj);
03337 
03338     if (RTEST(mode)) {
03339         gz->z.flags |= GZFILE_FLAG_SYNC;
03340     }
03341     else {
03342         gz->z.flags &= ~GZFILE_FLAG_SYNC;
03343     }
03344     return mode;
03345 }
03346 
03347 /*
03348  * Document-method: Zlib::GzipFile#total_in
03349  *
03350  * Total number of input bytes read so far.
03351  */
03352 static VALUE
03353 rb_gzfile_total_in(VALUE obj)
03354 {
03355     return rb_uint2inum(get_gzfile(obj)->z.stream.total_in);
03356 }
03357 
03358 /*
03359  * Document-method: Zlib::GzipFile#total_out
03360  *
03361  * Total number of output bytes output so far.
03362  */
03363 static VALUE
03364 rb_gzfile_total_out(VALUE obj)
03365 {
03366     struct gzfile *gz = get_gzfile(obj);
03367     return rb_uint2inum(gz->z.stream.total_out - gz->z.buf_filled);
03368 }
03369 
03370 /*
03371  * Document-method: Zlib::GzipFile#path
03372  *
03373  * call-seq: path
03374  *
03375  * Returns the path string of the associated IO-like object.  This
03376  * method is only defined when the IO-like object responds to #path().
03377  */
03378 static VALUE
03379 rb_gzfile_path(VALUE obj)
03380 {
03381     struct gzfile *gz;
03382     Data_Get_Struct(obj, struct gzfile, gz);
03383     return gz->path;
03384 }
03385 
03386 static void
03387 rb_gzfile_ecopts(struct gzfile *gz, VALUE opts)
03388 {
03389     if (!NIL_P(opts)) {
03390         rb_io_extract_encoding_option(opts, &gz->enc, &gz->enc2, NULL);
03391     }
03392     if (gz->enc2) {
03393         gz->ecflags = rb_econv_prepare_opts(opts, &opts);
03394         gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
03395                                     gz->ecflags, opts);
03396         gz->ecopts = opts;
03397     }
03398 }
03399 
03400 /* ------------------------------------------------------------------------- */
03401 
03402 /*
03403  * Document-class: Zlib::GzipWriter
03404  *
03405  * Zlib::GzipWriter is a class for writing gzipped files.  GzipWriter should
03406  * be used with an instance of IO, or IO-like, object.
03407  *
03408  * Following two example generate the same result.
03409  *
03410  *   Zlib::GzipWriter.open('hoge.gz') do |gz|
03411  *     gz.write 'jugemu jugemu gokou no surikire...'
03412  *   end
03413  *
03414  *   File.open('hoge.gz', 'w') do |f|
03415  *     gz = Zlib::GzipWriter.new(f)
03416  *     gz.write 'jugemu jugemu gokou no surikire...'
03417  *     gz.close
03418  *   end
03419  *
03420  * To make like gzip(1) does, run following:
03421  *
03422  *   orig = 'hoge.txt'
03423  *   Zlib::GzipWriter.open('hoge.gz') do |gz|
03424  *     gz.mtime = File.mtime(orig)
03425  *     gz.orig_name = orig
03426  *     gz.write IO.binread(orig)
03427  *   end
03428  *
03429  * NOTE: Due to the limitation of Ruby's finalizer, you must explicitly close
03430  * GzipWriter objects by Zlib::GzipWriter#close etc.  Otherwise, GzipWriter
03431  * will be not able to write the gzip footer and will generate a broken gzip
03432  * file.
03433  */
03434 
03435 static VALUE
03436 rb_gzwriter_s_allocate(VALUE klass)
03437 {
03438     return gzfile_writer_new(klass);
03439 }
03440 
03441 /*
03442  * call-seq: Zlib::GzipWriter.open(filename, level=nil, strategy=nil) { |gz| ... }
03443  *
03444  * Opens a file specified by +filename+ for writing gzip compressed data, and
03445  * returns a GzipWriter object associated with that file.  Further details of
03446  * this method are found in Zlib::GzipWriter.new and Zlib::GzipFile.wrap.
03447  */
03448 static VALUE
03449 rb_gzwriter_s_open(int argc, VALUE *argv, VALUE klass)
03450 {
03451     return gzfile_s_open(argc, argv, klass, "wb");
03452 }
03453 
03454 /*
03455  * call-seq:
03456  *   Zlib::GzipWriter.new(io, level = nil, strategy = nil, options = {})
03457  *
03458  * Creates a GzipWriter object associated with +io+. +level+ and +strategy+
03459  * should be the same as the arguments of Zlib::Deflate.new.  The GzipWriter
03460  * object writes gzipped data to +io+.  +io+ must respond to the
03461  * +write+ method that behaves the same as IO#write.
03462  *
03463  * The +options+ hash may be used to set the encoding of the data.
03464  * +:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
03465  * IO::new.
03466  */
03467 static VALUE
03468 rb_gzwriter_initialize(int argc, VALUE *argv, VALUE obj)
03469 {
03470     struct gzfile *gz;
03471     VALUE io, level, strategy, opt = Qnil;
03472     int err;
03473 
03474     if (argc > 1) {
03475         opt = rb_check_convert_type(argv[argc-1], T_HASH, "Hash", "to_hash");
03476         if (!NIL_P(opt)) argc--;
03477     }
03478 
03479     rb_scan_args(argc, argv, "12", &io, &level, &strategy);
03480     Data_Get_Struct(obj, struct gzfile, gz);
03481 
03482     /* this is undocumented feature of zlib */
03483     gz->level = ARG_LEVEL(level);
03484     err = deflateInit2(&gz->z.stream, gz->level, Z_DEFLATED,
03485                        -MAX_WBITS, DEF_MEM_LEVEL, ARG_STRATEGY(strategy));
03486     if (err != Z_OK) {
03487         raise_zlib_error(err, gz->z.stream.msg);
03488     }
03489     gz->io = io;
03490     ZSTREAM_READY(&gz->z);
03491     rb_gzfile_ecopts(gz, opt);
03492 
03493     if (rb_respond_to(io, id_path)) {
03494         gz->path = rb_funcall(gz->io, id_path, 0);
03495         rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
03496     }
03497 
03498     return obj;
03499 }
03500 
03501 /*
03502  * call-seq: flush(flush=nil)
03503  *
03504  * Flushes all the internal buffers of the GzipWriter object.  The meaning of
03505  * +flush+ is same as in Zlib::Deflate#deflate.  <tt>Zlib::SYNC_FLUSH</tt> is used if
03506  * +flush+ is omitted.  It is no use giving flush <tt>Zlib::NO_FLUSH</tt>.
03507  */
03508 static VALUE
03509 rb_gzwriter_flush(int argc, VALUE *argv, VALUE obj)
03510 {
03511     struct gzfile *gz = get_gzfile(obj);
03512     VALUE v_flush;
03513     int flush;
03514 
03515     rb_scan_args(argc, argv, "01", &v_flush);
03516 
03517     flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
03518     if (flush != Z_NO_FLUSH) {  /* prevent Z_BUF_ERROR */
03519         zstream_run(&gz->z, (Bytef*)"", 0, flush);
03520     }
03521 
03522     gzfile_write_raw(gz);
03523     if (rb_respond_to(gz->io, id_flush)) {
03524         rb_funcall(gz->io, id_flush, 0);
03525     }
03526     return obj;
03527 }
03528 
03529 /*
03530  * Same as IO.
03531  */
03532 static VALUE
03533 rb_gzwriter_write(VALUE obj, VALUE str)
03534 {
03535     struct gzfile *gz = get_gzfile(obj);
03536 
03537     if (!RB_TYPE_P(str, T_STRING))
03538         str = rb_obj_as_string(str);
03539     if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
03540         str = rb_str_conv_enc(str, rb_enc_get(str), gz->enc2);
03541     }
03542     gzfile_write(gz, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
03543     return INT2FIX(RSTRING_LEN(str));
03544 }
03545 
03546 /*
03547  * Same as IO.
03548  */
03549 static VALUE
03550 rb_gzwriter_putc(VALUE obj, VALUE ch)
03551 {
03552     struct gzfile *gz = get_gzfile(obj);
03553     char c = NUM2CHR(ch);
03554 
03555     gzfile_write(gz, (Bytef*)&c, 1);
03556     return ch;
03557 }
03558 
03559 
03560 
03561 /*
03562  * Document-method: <<
03563  * Same as IO.
03564  */
03565 #define rb_gzwriter_addstr  rb_io_addstr
03566 /*
03567  * Document-method: printf
03568  * Same as IO.
03569  */
03570 #define rb_gzwriter_printf  rb_io_printf
03571 /*
03572  * Document-method: print
03573  * Same as IO.
03574  */
03575 #define rb_gzwriter_print  rb_io_print
03576 /*
03577  * Document-method: puts
03578  * Same as IO.
03579  */
03580 #define rb_gzwriter_puts  rb_io_puts
03581 
03582 
03583 /* ------------------------------------------------------------------------- */
03584 
03585 /*
03586  * Document-class: Zlib::GzipReader
03587  *
03588  * Zlib::GzipReader is the class for reading a gzipped file.  GzipReader should
03589  * be used an IO, or -IO-like, object.
03590  *
03591  *   Zlib::GzipReader.open('hoge.gz') {|gz|
03592  *     print gz.read
03593  *   }
03594  *
03595  *   File.open('hoge.gz') do |f|
03596  *     gz = Zlib::GzipReader.new(f)
03597  *     print gz.read
03598  *     gz.close
03599  *   end
03600  *
03601  * == Method Catalogue
03602  *
03603  * The following methods in Zlib::GzipReader are just like their counterparts
03604  * in IO, but they raise Zlib::Error or Zlib::GzipFile::Error exception if an
03605  * error was found in the gzip file.
03606  * - #each
03607  * - #each_line
03608  * - #each_byte
03609  * - #gets
03610  * - #getc
03611  * - #lineno
03612  * - #lineno=
03613  * - #read
03614  * - #readchar
03615  * - #readline
03616  * - #readlines
03617  * - #ungetc
03618  *
03619  * Be careful of the footer of the gzip file. A gzip file has the checksum of
03620  * pre-compressed data in its footer. GzipReader checks all uncompressed data
03621  * against that checksum at the following cases, and if it fails, raises
03622  * <tt>Zlib::GzipFile::NoFooter</tt>, <tt>Zlib::GzipFile::CRCError</tt>, or
03623  * <tt>Zlib::GzipFile::LengthError</tt> exception.
03624  *
03625  * - When an reading request is received beyond the end of file (the end of
03626  *   compressed data). That is, when Zlib::GzipReader#read,
03627  *   Zlib::GzipReader#gets, or some other methods for reading returns nil.
03628  * - When Zlib::GzipFile#close method is called after the object reaches the
03629  *   end of file.
03630  * - When Zlib::GzipReader#unused method is called after the object reaches
03631  *   the end of file.
03632  *
03633  * The rest of the methods are adequately described in their own
03634  * documentation.
03635  */
03636 
03637 static VALUE
03638 rb_gzreader_s_allocate(VALUE klass)
03639 {
03640     return gzfile_reader_new(klass);
03641 }
03642 
03643 /*
03644  * Document-method: Zlib::GzipReader.open
03645  *
03646  * call-seq: Zlib::GzipReader.open(filename) {|gz| ... }
03647  *
03648  * Opens a file specified by +filename+ as a gzipped file, and returns a
03649  * GzipReader object associated with that file.  Further details of this method
03650  * are in Zlib::GzipReader.new and ZLib::GzipFile.wrap.
03651  */
03652 static VALUE
03653 rb_gzreader_s_open(int argc, VALUE *argv, VALUE klass)
03654 {
03655     return gzfile_s_open(argc, argv, klass, "rb");
03656 }
03657 
03658 /*
03659  * Document-method: Zlib::GzipReader.new
03660  *
03661  * call-seq:
03662  *   Zlib::GzipReader.new(io, options = {})
03663  *
03664  * Creates a GzipReader object associated with +io+. The GzipReader object reads
03665  * gzipped data from +io+, and parses/decompresses it.  The +io+ must
03666  * have a +read+ method that behaves same as the IO#read.
03667  *
03668  * The +options+ hash may be used to set the encoding of the data.
03669  * +:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
03670  * IO::new.
03671  *
03672  * If the gzip file header is incorrect, raises an Zlib::GzipFile::Error
03673  * exception.
03674  */
03675 static VALUE
03676 rb_gzreader_initialize(int argc, VALUE *argv, VALUE obj)
03677 {
03678     VALUE io, opt = Qnil;
03679     struct gzfile *gz;
03680     int err;
03681 
03682     Data_Get_Struct(obj, struct gzfile, gz);
03683     rb_scan_args(argc, argv, "1:", &io, &opt);
03684 
03685     /* this is undocumented feature of zlib */
03686     err = inflateInit2(&gz->z.stream, -MAX_WBITS);
03687     if (err != Z_OK) {
03688         raise_zlib_error(err, gz->z.stream.msg);
03689     }
03690     gz->io = io;
03691     ZSTREAM_READY(&gz->z);
03692     gzfile_read_header(gz);
03693     rb_gzfile_ecopts(gz, opt);
03694 
03695     if (rb_respond_to(io, id_path)) {
03696         gz->path = rb_funcall(gz->io, id_path, 0);
03697         rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
03698     }
03699 
03700     return obj;
03701 }
03702 
03703 /*
03704  * Document-method: Zlib::GzipReader#rewind
03705  *
03706  * Resets the position of the file pointer to the point created the GzipReader
03707  * object.  The associated IO object needs to respond to the +seek+ method.
03708  */
03709 static VALUE
03710 rb_gzreader_rewind(VALUE obj)
03711 {
03712     struct gzfile *gz = get_gzfile(obj);
03713     gzfile_reader_rewind(gz);
03714     return INT2FIX(0);
03715 }
03716 
03717 /*
03718  * Document-method: Zlib::GzipReader#unused
03719  *
03720  * Returns the rest of the data which had read for parsing gzip format, or
03721  * +nil+ if the whole gzip file is not parsed yet.
03722  */
03723 static VALUE
03724 rb_gzreader_unused(VALUE obj)
03725 {
03726     struct gzfile *gz;
03727     Data_Get_Struct(obj, struct gzfile, gz);
03728     return gzfile_reader_get_unused(gz);
03729 }
03730 
03731 /*
03732  * Document-method: Zlib::GzipReader#read
03733  *
03734  * See Zlib::GzipReader documentation for a description.
03735  */
03736 static VALUE
03737 rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
03738 {
03739     struct gzfile *gz = get_gzfile(obj);
03740     VALUE vlen;
03741     long len;
03742 
03743     rb_scan_args(argc, argv, "01", &vlen);
03744     if (NIL_P(vlen)) {
03745         return gzfile_read_all(gz);
03746     }
03747 
03748     len = NUM2INT(vlen);
03749     if (len < 0) {
03750         rb_raise(rb_eArgError, "negative length %ld given", len);
03751     }
03752     return gzfile_read(gz, len);
03753 }
03754 
03755 /*
03756  * Document-method: Zlib::GzipReader#readpartial
03757  *
03758  *  call-seq:
03759  *     gzipreader.readpartial(maxlen [, outbuf]) => string, outbuf
03760  *
03761  *  Reads at most <i>maxlen</i> bytes from the gziped stream but
03762  *  it blocks only if <em>gzipreader</em> has no data immediately available.
03763  *  If the optional <i>outbuf</i> argument is present,
03764  *  it must reference a String, which will receive the data.
03765  *  It raises <code>EOFError</code> on end of file.
03766  */
03767 static VALUE
03768 rb_gzreader_readpartial(int argc, VALUE *argv, VALUE obj)
03769 {
03770     struct gzfile *gz = get_gzfile(obj);
03771     VALUE vlen, outbuf;
03772     long len;
03773 
03774     rb_scan_args(argc, argv, "11", &vlen, &outbuf);
03775 
03776     len = NUM2INT(vlen);
03777     if (len < 0) {
03778         rb_raise(rb_eArgError, "negative length %ld given", len);
03779     }
03780     if (!NIL_P(outbuf))
03781         Check_Type(outbuf, T_STRING);
03782     return gzfile_readpartial(gz, len, outbuf);
03783 }
03784 
03785 /*
03786  * Document-method: Zlib::GzipReader#getc
03787  *
03788  * See Zlib::GzipReader documentation for a description.
03789  */
03790 static VALUE
03791 rb_gzreader_getc(VALUE obj)
03792 {
03793     struct gzfile *gz = get_gzfile(obj);
03794 
03795     return gzfile_getc(gz);
03796 }
03797 
03798 /*
03799  * Document-method: Zlib::GzipReader#readchar
03800  *
03801  * See Zlib::GzipReader documentation for a description.
03802  */
03803 static VALUE
03804 rb_gzreader_readchar(VALUE obj)
03805 {
03806     VALUE dst;
03807     dst = rb_gzreader_getc(obj);
03808     if (NIL_P(dst)) {
03809         rb_raise(rb_eEOFError, "end of file reached");
03810     }
03811     return dst;
03812 }
03813 
03814 /*
03815  * Document-method: Zlib::GzipReader#getbyte
03816  *
03817  * See Zlib::GzipReader documentation for a description.
03818  */
03819 static VALUE
03820 rb_gzreader_getbyte(VALUE obj)
03821 {
03822     struct gzfile *gz = get_gzfile(obj);
03823     VALUE dst;
03824 
03825     dst = gzfile_read(gz, 1);
03826     if (!NIL_P(dst)) {
03827         dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
03828     }
03829     return dst;
03830 }
03831 
03832 /*
03833  * Document-method: Zlib::GzipReader#readbyte
03834  *
03835  * See Zlib::GzipReader documentation for a description.
03836  */
03837 static VALUE
03838 rb_gzreader_readbyte(VALUE obj)
03839 {
03840     VALUE dst;
03841     dst = rb_gzreader_getbyte(obj);
03842     if (NIL_P(dst)) {
03843         rb_raise(rb_eEOFError, "end of file reached");
03844     }
03845     return dst;
03846 }
03847 
03848 /*
03849  * Document-method: Zlib::GzipReader#each_char
03850  *
03851  * See Zlib::GzipReader documentation for a description.
03852  */
03853 static VALUE
03854 rb_gzreader_each_char(VALUE obj)
03855 {
03856     VALUE c;
03857 
03858     RETURN_ENUMERATOR(obj, 0, 0);
03859 
03860     while (!NIL_P(c = rb_gzreader_getc(obj))) {
03861         rb_yield(c);
03862     }
03863     return Qnil;
03864 }
03865 
03866 /*
03867  * Document-method: Zlib::GzipReader#each_byte
03868  *
03869  * See Zlib::GzipReader documentation for a description.
03870  */
03871 static VALUE
03872 rb_gzreader_each_byte(VALUE obj)
03873 {
03874     VALUE c;
03875 
03876     RETURN_ENUMERATOR(obj, 0, 0);
03877 
03878     while (!NIL_P(c = rb_gzreader_getbyte(obj))) {
03879         rb_yield(c);
03880     }
03881     return Qnil;
03882 }
03883 
03884 /*
03885  * Document-method: Zlib::GzipReader#bytes
03886  *
03887  *  This is a deprecated alias for <code>each_byte</code>.
03888  */
03889 static VALUE
03890 rb_gzreader_bytes(VALUE obj)
03891 {
03892     rb_warn("Zlib::GzipReader#bytes is deprecated; use #each_byte instead");
03893     if (!rb_block_given_p())
03894         return rb_enumeratorize(obj, ID2SYM(rb_intern("each_byte")), 0, 0);
03895     return rb_gzreader_each_byte(obj);
03896 }
03897 
03898 /*
03899  * Document-method: Zlib::GzipReader#ungetc
03900  *
03901  * See Zlib::GzipReader documentation for a description.
03902  */
03903 static VALUE
03904 rb_gzreader_ungetc(VALUE obj, VALUE s)
03905 {
03906     struct gzfile *gz;
03907 
03908     if (FIXNUM_P(s))
03909         return rb_gzreader_ungetbyte(obj, s);
03910     gz = get_gzfile(obj);
03911     StringValue(s);
03912     if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
03913         s = rb_str_conv_enc(s, rb_enc_get(s), gz->enc2);
03914     }
03915     gzfile_ungets(gz, (const Bytef*)RSTRING_PTR(s), RSTRING_LEN(s));
03916     return Qnil;
03917 }
03918 
03919 /*
03920  * Document-method: Zlib::GzipReader#ungetbyte
03921  *
03922  * See Zlib::GzipReader documentation for a description.
03923  */
03924 static VALUE
03925 rb_gzreader_ungetbyte(VALUE obj, VALUE ch)
03926 {
03927     struct gzfile *gz = get_gzfile(obj);
03928     gzfile_ungetbyte(gz, NUM2CHR(ch));
03929     return Qnil;
03930 }
03931 
03932 static void
03933 gzreader_skip_linebreaks(struct gzfile *gz)
03934 {
03935     VALUE str;
03936     char *p;
03937     int n;
03938 
03939     while (gz->z.buf_filled == 0) {
03940         if (GZFILE_IS_FINISHED(gz)) return;
03941         gzfile_read_more(gz);
03942     }
03943     n = 0;
03944     p = RSTRING_PTR(gz->z.buf);
03945 
03946     while (n++, *(p++) == '\n') {
03947         if (n >= gz->z.buf_filled) {
03948             str = zstream_detach_buffer(&gz->z);
03949             gzfile_calc_crc(gz, str);
03950             while (gz->z.buf_filled == 0) {
03951                 if (GZFILE_IS_FINISHED(gz)) return;
03952                 gzfile_read_more(gz);
03953             }
03954             n = 0;
03955             p = RSTRING_PTR(gz->z.buf);
03956         }
03957     }
03958 
03959     str = zstream_shift_buffer(&gz->z, n - 1);
03960     gzfile_calc_crc(gz, str);
03961 }
03962 
03963 static void
03964 rscheck(const char *rsptr, long rslen, VALUE rs)
03965 {
03966     if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen)
03967         rb_raise(rb_eRuntimeError, "rs modified");
03968 }
03969 
03970 static long
03971 gzreader_charboundary(struct gzfile *gz, long n)
03972 {
03973     char *s = RSTRING_PTR(gz->z.buf);
03974     char *e = s + gz->z.buf_filled;
03975     char *p = rb_enc_left_char_head(s, s + n, e, gz->enc);
03976     long l = p - s;
03977     if (l < n) {
03978         n = rb_enc_precise_mbclen(p, e, gz->enc);
03979         if (MBCLEN_NEEDMORE_P(n)) {
03980             if ((l = gzfile_fill(gz, l + MBCLEN_NEEDMORE_LEN(n))) > 0) {
03981                 return l;
03982             }
03983         }
03984         else if (MBCLEN_CHARFOUND_P(n)) {
03985             return l + MBCLEN_CHARFOUND_LEN(n);
03986         }
03987     }
03988     return n;
03989 }
03990 
03991 static VALUE
03992 gzreader_gets(int argc, VALUE *argv, VALUE obj)
03993 {
03994     struct gzfile *gz = get_gzfile(obj);
03995     volatile VALUE rs;
03996     VALUE dst;
03997     const char *rsptr;
03998     char *p, *res;
03999     long rslen, n, limit = -1;
04000     int rspara;
04001     rb_encoding *enc = gz->enc;
04002     int maxlen = rb_enc_mbmaxlen(enc);
04003 
04004     if (argc == 0) {
04005         rs = rb_rs;
04006     }
04007     else {
04008         VALUE lim, tmp;
04009 
04010         rb_scan_args(argc, argv, "11", &rs, &lim);
04011         if (!NIL_P(lim)) {
04012             if (!NIL_P(rs)) StringValue(rs);
04013         }
04014         else if (!NIL_P(rs)) {
04015             tmp = rb_check_string_type(rs);
04016             if (NIL_P(tmp)) {
04017                 lim = rs;
04018                 rs = rb_rs;
04019             }
04020             else {
04021                 rs = tmp;
04022             }
04023         }
04024         if (!NIL_P(lim)) {
04025             limit = NUM2LONG(lim);
04026             if (limit == 0) return rb_str_new(0,0);
04027         }
04028     }
04029 
04030     if (NIL_P(rs)) {
04031         if (limit < 0) {
04032             dst = gzfile_read_all(gz);
04033             if (RSTRING_LEN(dst) == 0) return Qnil;
04034         }
04035         else if ((n = gzfile_fill(gz, limit)) <= 0) {
04036             return Qnil;
04037         }
04038         else {
04039             if (maxlen > 1 && n >= limit && !GZFILE_IS_FINISHED(gz)) {
04040                 n = gzreader_charboundary(gz, n);
04041             }
04042             else {
04043                 n = limit;
04044             }
04045             dst = zstream_shift_buffer(&gz->z, n);
04046             if (NIL_P(dst)) return dst;
04047             gzfile_calc_crc(gz, dst);
04048             dst = gzfile_newstr(gz, dst);
04049         }
04050         gz->lineno++;
04051         return dst;
04052     }
04053 
04054     if (RSTRING_LEN(rs) == 0) {
04055         rsptr = "\n\n";
04056         rslen = 2;
04057         rspara = 1;
04058     } else {
04059         rsptr = RSTRING_PTR(rs);
04060         rslen = RSTRING_LEN(rs);
04061         rspara = 0;
04062     }
04063 
04064     if (rspara) {
04065         gzreader_skip_linebreaks(gz);
04066     }
04067 
04068     while (gz->z.buf_filled < rslen) {
04069         if (ZSTREAM_IS_FINISHED(&gz->z)) {
04070             if (gz->z.buf_filled > 0) gz->lineno++;
04071             return gzfile_read(gz, rslen);
04072         }
04073         gzfile_read_more(gz);
04074     }
04075 
04076     p = RSTRING_PTR(gz->z.buf);
04077     n = rslen;
04078     for (;;) {
04079         long filled;
04080         if (n > gz->z.buf_filled) {
04081             if (ZSTREAM_IS_FINISHED(&gz->z)) break;
04082             gzfile_read_more(gz);
04083             p = RSTRING_PTR(gz->z.buf) + n - rslen;
04084         }
04085         if (!rspara) rscheck(rsptr, rslen, rs);
04086         filled = gz->z.buf_filled;
04087         if (limit > 0 && filled >= limit) {
04088             filled = limit;
04089         }
04090         res = memchr(p, rsptr[0], (filled - n + 1));
04091         if (!res) {
04092             n = filled;
04093             if (limit > 0 && filled >= limit) break;
04094             n++;
04095         } else {
04096             n += (long)(res - p);
04097             p = res;
04098             if (rslen == 1 || memcmp(p, rsptr, rslen) == 0) break;
04099             p++, n++;
04100         }
04101     }
04102     if (maxlen > 1 && n == limit && (gz->z.buf_filled > n || !ZSTREAM_IS_FINISHED(&gz->z))) {
04103         n = gzreader_charboundary(gz, n);
04104     }
04105 
04106     gz->lineno++;
04107     dst = gzfile_read(gz, n);
04108     if (NIL_P(dst)) return dst;
04109     if (rspara) {
04110         gzreader_skip_linebreaks(gz);
04111     }
04112 
04113     return gzfile_newstr(gz, dst);
04114 }
04115 
04116 /*
04117  * Document-method: Zlib::GzipReader#gets
04118  *
04119  * See Zlib::GzipReader documentation for a description.
04120  */
04121 static VALUE
04122 rb_gzreader_gets(int argc, VALUE *argv, VALUE obj)
04123 {
04124     VALUE dst;
04125     dst = gzreader_gets(argc, argv, obj);
04126     if (!NIL_P(dst)) {
04127         rb_lastline_set(dst);
04128     }
04129     return dst;
04130 }
04131 
04132 /*
04133  * Document-method: Zlib::GzipReader#readline
04134  *
04135  * See Zlib::GzipReader documentation for a description.
04136  */
04137 static VALUE
04138 rb_gzreader_readline(int argc, VALUE *argv, VALUE obj)
04139 {
04140     VALUE dst;
04141     dst = rb_gzreader_gets(argc, argv, obj);
04142     if (NIL_P(dst)) {
04143         rb_raise(rb_eEOFError, "end of file reached");
04144     }
04145     return dst;
04146 }
04147 
04148 /*
04149  * Document-method: Zlib::GzipReader#each
04150  *
04151  * See Zlib::GzipReader documentation for a description.
04152  */
04153 static VALUE
04154 rb_gzreader_each(int argc, VALUE *argv, VALUE obj)
04155 {
04156     VALUE str;
04157 
04158     RETURN_ENUMERATOR(obj, 0, 0);
04159 
04160     while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
04161         rb_yield(str);
04162     }
04163     return obj;
04164 }
04165 
04166 /*
04167  * Document-method: Zlib::GzipReader#lines
04168  *
04169  *  This is a deprecated alias for <code>each_line</code>.
04170  */
04171 static VALUE
04172 rb_gzreader_lines(int argc, VALUE *argv, VALUE obj)
04173 {
04174     rb_warn("Zlib::GzipReader#lines is deprecated; use #each_line instead");
04175     if (!rb_block_given_p())
04176         return rb_enumeratorize(obj, ID2SYM(rb_intern("each_line")), argc, argv);
04177     return rb_gzreader_each(argc, argv, obj);
04178 }
04179 
04180 /*
04181  * Document-method: Zlib::GzipReader#readlines
04182  *
04183  * See Zlib::GzipReader documentation for a description.
04184  */
04185 static VALUE
04186 rb_gzreader_readlines(int argc, VALUE *argv, VALUE obj)
04187 {
04188     VALUE str, dst;
04189     dst = rb_ary_new();
04190     while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
04191         rb_ary_push(dst, str);
04192     }
04193     return dst;
04194 }
04195 
04196 #endif /* GZIP_SUPPORT */
04197 
04198 void
04199 Init_zlib()
04200 {
04201     VALUE mZlib, cZStream, cDeflate, cInflate;
04202 #if GZIP_SUPPORT
04203     VALUE cGzipFile, cGzipWriter, cGzipReader;
04204 #endif
04205 
04206     mZlib = rb_define_module("Zlib");
04207 
04208     id_dictionaries = rb_intern("@dictionaries");
04209 
04210     cZError = rb_define_class_under(mZlib, "Error", rb_eStandardError);
04211     cStreamEnd    = rb_define_class_under(mZlib, "StreamEnd", cZError);
04212     cNeedDict     = rb_define_class_under(mZlib, "NeedDict", cZError);
04213     cDataError    = rb_define_class_under(mZlib, "DataError", cZError);
04214     cStreamError  = rb_define_class_under(mZlib, "StreamError", cZError);
04215     cMemError     = rb_define_class_under(mZlib, "MemError", cZError);
04216     cBufError     = rb_define_class_under(mZlib, "BufError", cZError);
04217     cVersionError = rb_define_class_under(mZlib, "VersionError", cZError);
04218 
04219     rb_define_module_function(mZlib, "zlib_version", rb_zlib_version, 0);
04220     rb_define_module_function(mZlib, "adler32", rb_zlib_adler32, -1);
04221     rb_define_module_function(mZlib, "adler32_combine", rb_zlib_adler32_combine, 3);
04222     rb_define_module_function(mZlib, "crc32", rb_zlib_crc32, -1);
04223     rb_define_module_function(mZlib, "crc32_combine", rb_zlib_crc32_combine, 3);
04224     rb_define_module_function(mZlib, "crc_table", rb_zlib_crc_table, 0);
04225 
04226     /* The Ruby/zlib version string. */
04227     rb_define_const(mZlib, "VERSION", rb_str_new2(RUBY_ZLIB_VERSION));
04228     /*  The string which represents the version of zlib.h */
04229     rb_define_const(mZlib, "ZLIB_VERSION", rb_str_new2(ZLIB_VERSION));
04230 
04231     cZStream = rb_define_class_under(mZlib, "ZStream", rb_cObject);
04232     rb_undef_alloc_func(cZStream);
04233     rb_define_method(cZStream, "avail_out", rb_zstream_avail_out, 0);
04234     rb_define_method(cZStream, "avail_out=", rb_zstream_set_avail_out, 1);
04235     rb_define_method(cZStream, "avail_in", rb_zstream_avail_in, 0);
04236     rb_define_method(cZStream, "total_in", rb_zstream_total_in, 0);
04237     rb_define_method(cZStream, "total_out", rb_zstream_total_out, 0);
04238     rb_define_method(cZStream, "data_type", rb_zstream_data_type, 0);
04239     rb_define_method(cZStream, "adler", rb_zstream_adler, 0);
04240     rb_define_method(cZStream, "finished?", rb_zstream_finished_p, 0);
04241     rb_define_method(cZStream, "stream_end?", rb_zstream_finished_p, 0);
04242     rb_define_method(cZStream, "closed?", rb_zstream_closed_p, 0);
04243     rb_define_method(cZStream, "ended?", rb_zstream_closed_p, 0);
04244     rb_define_method(cZStream, "close", rb_zstream_end, 0);
04245     rb_define_method(cZStream, "end", rb_zstream_end, 0);
04246     rb_define_method(cZStream, "reset", rb_zstream_reset, 0);
04247     rb_define_method(cZStream, "finish", rb_zstream_finish, 0);
04248     rb_define_method(cZStream, "flush_next_in", rb_zstream_flush_next_in, 0);
04249     rb_define_method(cZStream, "flush_next_out", rb_zstream_flush_next_out, 0);
04250 
04251     /* Represents binary data as guessed by deflate.
04252      *
04253      * See Zlib::Deflate#data_type. */
04254     rb_define_const(mZlib, "BINARY", INT2FIX(Z_BINARY));
04255 
04256     /* Represents text data as guessed by deflate.
04257      *
04258      * NOTE: The underlying constant Z_ASCII was deprecated in favor of Z_TEXT
04259      * in zlib 1.2.2.  New applications should not use this constant.
04260      *
04261      * See Zlib::Deflate#data_type. */
04262     rb_define_const(mZlib, "ASCII", INT2FIX(Z_ASCII));
04263 
04264 #ifdef Z_TEXT
04265     /* Represents text data as guessed by deflate.
04266      *
04267      * See Zlib::Deflate#data_type. */
04268     rb_define_const(mZlib, "TEXT", INT2FIX(Z_TEXT));
04269 #endif
04270 
04271     /* Represents an unknown data type as guessed by deflate.
04272      *
04273      * See Zlib::Deflate#data_type. */
04274     rb_define_const(mZlib, "UNKNOWN", INT2FIX(Z_UNKNOWN));
04275 
04276     cDeflate = rb_define_class_under(mZlib, "Deflate", cZStream);
04277     rb_define_singleton_method(cDeflate, "deflate", rb_deflate_s_deflate, -1);
04278     rb_define_singleton_method(mZlib, "deflate", rb_deflate_s_deflate, -1);
04279     rb_define_alloc_func(cDeflate, rb_deflate_s_allocate);
04280     rb_define_method(cDeflate, "initialize", rb_deflate_initialize, -1);
04281     rb_define_method(cDeflate, "initialize_copy", rb_deflate_init_copy, 1);
04282     rb_define_method(cDeflate, "deflate", rb_deflate_deflate, -1);
04283     rb_define_method(cDeflate, "<<", rb_deflate_addstr, 1);
04284     rb_define_method(cDeflate, "flush", rb_deflate_flush, -1);
04285     rb_define_method(cDeflate, "params", rb_deflate_params, 2);
04286     rb_define_method(cDeflate, "set_dictionary", rb_deflate_set_dictionary, 1);
04287 
04288     cInflate = rb_define_class_under(mZlib, "Inflate", cZStream);
04289     rb_define_singleton_method(cInflate, "inflate", rb_inflate_s_inflate, 1);
04290     rb_define_singleton_method(mZlib, "inflate", rb_inflate_s_inflate, 1);
04291     rb_define_alloc_func(cInflate, rb_inflate_s_allocate);
04292     rb_define_method(cInflate, "initialize", rb_inflate_initialize, -1);
04293     rb_define_method(cInflate, "add_dictionary", rb_inflate_add_dictionary, 1);
04294     rb_define_method(cInflate, "inflate", rb_inflate_inflate, 1);
04295     rb_define_method(cInflate, "<<", rb_inflate_addstr, 1);
04296     rb_define_method(cInflate, "sync", rb_inflate_sync, 1);
04297     rb_define_method(cInflate, "sync_point?", rb_inflate_sync_point_p, 0);
04298     rb_define_method(cInflate, "set_dictionary", rb_inflate_set_dictionary, 1);
04299 
04300     /* No compression, passes through data untouched.  Use this for appending
04301      * pre-compressed data to a deflate stream.
04302      */
04303     rb_define_const(mZlib, "NO_COMPRESSION", INT2FIX(Z_NO_COMPRESSION));
04304     /* Fastest compression level, but with with lowest space savings. */
04305     rb_define_const(mZlib, "BEST_SPEED", INT2FIX(Z_BEST_SPEED));
04306     /* Slowest compression level, but with the best space savings. */
04307     rb_define_const(mZlib, "BEST_COMPRESSION", INT2FIX(Z_BEST_COMPRESSION));
04308     /* Default compression level which is a good trade-off between space and
04309      * time
04310      */
04311     rb_define_const(mZlib, "DEFAULT_COMPRESSION",
04312                     INT2FIX(Z_DEFAULT_COMPRESSION));
04313 
04314     /* Deflate strategy for data produced by a filter (or predictor). The
04315      * effect of FILTERED is to force more Huffman codes and less string
04316      * matching; it is somewhat intermediate between DEFAULT_STRATEGY and
04317      * HUFFMAN_ONLY. Filtered data consists mostly of small values with a
04318      * somewhat random distribution.
04319      */
04320     rb_define_const(mZlib, "FILTERED", INT2FIX(Z_FILTERED));
04321 
04322     /* Deflate strategy which uses Huffman codes only (no string matching). */
04323     rb_define_const(mZlib, "HUFFMAN_ONLY", INT2FIX(Z_HUFFMAN_ONLY));
04324 
04325 #ifdef Z_RLE
04326     /* Deflate compression strategy designed to be almost as fast as
04327      * HUFFMAN_ONLY, but give better compression for PNG image data.
04328      */
04329     rb_define_const(mZlib, "RLE", INT2FIX(Z_RLE));
04330 #endif
04331 
04332 #ifdef Z_FIXED
04333     /* Deflate strategy which prevents the use of dynamic Huffman codes,
04334      * allowing for a simpler decoder for specialized applications.
04335      */
04336     rb_define_const(mZlib, "FIXED", INT2FIX(Z_FIXED));
04337 #endif
04338 
04339     /* Default deflate strategy which is used for normal data. */
04340     rb_define_const(mZlib, "DEFAULT_STRATEGY", INT2FIX(Z_DEFAULT_STRATEGY));
04341 
04342     /* The maximum size of the zlib history buffer.  Note that zlib allows
04343      * larger values to enable different inflate modes.  See Zlib::Inflate.new
04344      * for details.
04345      */
04346     rb_define_const(mZlib, "MAX_WBITS", INT2FIX(MAX_WBITS));
04347 
04348     /* The default memory level for allocating zlib deflate compression state.
04349      */
04350     rb_define_const(mZlib, "DEF_MEM_LEVEL", INT2FIX(DEF_MEM_LEVEL));
04351 
04352     /* The maximum memory level for allocating zlib deflate compression state.
04353      */
04354     rb_define_const(mZlib, "MAX_MEM_LEVEL", INT2FIX(MAX_MEM_LEVEL));
04355 
04356     /* NO_FLUSH is the default flush method and allows deflate to decide how
04357      * much data to accumulate before producing output in order to maximize
04358      * compression.
04359      */
04360     rb_define_const(mZlib, "NO_FLUSH", INT2FIX(Z_NO_FLUSH));
04361 
04362     /* The SYNC_FLUSH method flushes all pending output to the output buffer
04363      * and the output is aligned on a byte boundary. Flushing may degrade
04364      * compression so it should be used only when necessary, such as at a
04365      * request or response boundary for a network stream.
04366      */
04367     rb_define_const(mZlib, "SYNC_FLUSH", INT2FIX(Z_SYNC_FLUSH));
04368 
04369     /* Flushes all output as with SYNC_FLUSH, and the compression state is
04370      * reset so that decompression can restart from this point if previous
04371      * compressed data has been damaged or if random access is desired. Like
04372      * SYNC_FLUSH, using FULL_FLUSH too often can seriously degrade
04373      * compression.
04374      */
04375     rb_define_const(mZlib, "FULL_FLUSH", INT2FIX(Z_FULL_FLUSH));
04376 
04377     /* Processes all pending input and flushes pending output. */
04378     rb_define_const(mZlib, "FINISH", INT2FIX(Z_FINISH));
04379 
04380 #if GZIP_SUPPORT
04381     id_write = rb_intern("write");
04382     id_read = rb_intern("read");
04383     id_readpartial = rb_intern("readpartial");
04384     id_flush = rb_intern("flush");
04385     id_seek = rb_intern("seek");
04386     id_close = rb_intern("close");
04387     id_path = rb_intern("path");
04388     id_input = rb_intern("@input");
04389 
04390     cGzipFile = rb_define_class_under(mZlib, "GzipFile", rb_cObject);
04391     cGzError = rb_define_class_under(cGzipFile, "Error", cZError);
04392 
04393     /* input gzipped string */
04394     rb_define_attr(cGzError, "input", 1, 0);
04395     rb_define_method(cGzError, "inspect", gzfile_error_inspect, 0);
04396 
04397     cNoFooter = rb_define_class_under(cGzipFile, "NoFooter", cGzError);
04398     cCRCError = rb_define_class_under(cGzipFile, "CRCError", cGzError);
04399     cLengthError = rb_define_class_under(cGzipFile,"LengthError",cGzError);
04400 
04401     cGzipWriter = rb_define_class_under(mZlib, "GzipWriter", cGzipFile);
04402     cGzipReader = rb_define_class_under(mZlib, "GzipReader", cGzipFile);
04403     rb_include_module(cGzipReader, rb_mEnumerable);
04404 
04405     rb_define_singleton_method(cGzipFile, "wrap", rb_gzfile_s_wrap, -1);
04406     rb_undef_alloc_func(cGzipFile);
04407     rb_define_method(cGzipFile, "to_io", rb_gzfile_to_io, 0);
04408     rb_define_method(cGzipFile, "crc", rb_gzfile_crc, 0);
04409     rb_define_method(cGzipFile, "mtime", rb_gzfile_mtime, 0);
04410     rb_define_method(cGzipFile, "level", rb_gzfile_level, 0);
04411     rb_define_method(cGzipFile, "os_code", rb_gzfile_os_code, 0);
04412     rb_define_method(cGzipFile, "orig_name", rb_gzfile_orig_name, 0);
04413     rb_define_method(cGzipFile, "comment", rb_gzfile_comment, 0);
04414     rb_define_method(cGzipReader, "lineno", rb_gzfile_lineno, 0);
04415     rb_define_method(cGzipReader, "lineno=", rb_gzfile_set_lineno, 1);
04416     rb_define_method(cGzipWriter, "mtime=", rb_gzfile_set_mtime, 1);
04417     rb_define_method(cGzipWriter, "orig_name=", rb_gzfile_set_orig_name,1);
04418     rb_define_method(cGzipWriter, "comment=", rb_gzfile_set_comment, 1);
04419     rb_define_method(cGzipFile, "close", rb_gzfile_close, 0);
04420     rb_define_method(cGzipFile, "finish", rb_gzfile_finish, 0);
04421     rb_define_method(cGzipFile, "closed?", rb_gzfile_closed_p, 0);
04422     rb_define_method(cGzipReader, "eof", rb_gzfile_eof_p, 0);
04423     rb_define_method(cGzipReader, "eof?", rb_gzfile_eof_p, 0);
04424     rb_define_method(cGzipFile, "sync", rb_gzfile_sync, 0);
04425     rb_define_method(cGzipFile, "sync=", rb_gzfile_set_sync, 1);
04426     rb_define_method(cGzipReader, "pos", rb_gzfile_total_out, 0);
04427     rb_define_method(cGzipWriter, "pos", rb_gzfile_total_in, 0);
04428     rb_define_method(cGzipReader, "tell", rb_gzfile_total_out, 0);
04429     rb_define_method(cGzipWriter, "tell", rb_gzfile_total_in, 0);
04430 
04431     rb_define_singleton_method(cGzipWriter, "open", rb_gzwriter_s_open,-1);
04432     rb_define_alloc_func(cGzipWriter, rb_gzwriter_s_allocate);
04433     rb_define_method(cGzipWriter, "initialize", rb_gzwriter_initialize,-1);
04434     rb_define_method(cGzipWriter, "flush", rb_gzwriter_flush, -1);
04435     rb_define_method(cGzipWriter, "write", rb_gzwriter_write, 1);
04436     rb_define_method(cGzipWriter, "putc", rb_gzwriter_putc, 1);
04437     rb_define_method(cGzipWriter, "<<", rb_gzwriter_addstr, 1);
04438     rb_define_method(cGzipWriter, "printf", rb_gzwriter_printf, -1);
04439     rb_define_method(cGzipWriter, "print", rb_gzwriter_print, -1);
04440     rb_define_method(cGzipWriter, "puts", rb_gzwriter_puts, -1);
04441 
04442     rb_define_singleton_method(cGzipReader, "open", rb_gzreader_s_open,-1);
04443     rb_define_alloc_func(cGzipReader, rb_gzreader_s_allocate);
04444     rb_define_method(cGzipReader, "initialize", rb_gzreader_initialize, -1);
04445     rb_define_method(cGzipReader, "rewind", rb_gzreader_rewind, 0);
04446     rb_define_method(cGzipReader, "unused", rb_gzreader_unused, 0);
04447     rb_define_method(cGzipReader, "read", rb_gzreader_read, -1);
04448     rb_define_method(cGzipReader, "readpartial", rb_gzreader_readpartial, -1);
04449     rb_define_method(cGzipReader, "getc", rb_gzreader_getc, 0);
04450     rb_define_method(cGzipReader, "getbyte", rb_gzreader_getbyte, 0);
04451     rb_define_method(cGzipReader, "readchar", rb_gzreader_readchar, 0);
04452     rb_define_method(cGzipReader, "readbyte", rb_gzreader_readbyte, 0);
04453     rb_define_method(cGzipReader, "each_byte", rb_gzreader_each_byte, 0);
04454     rb_define_method(cGzipReader, "each_char", rb_gzreader_each_char, 0);
04455     rb_define_method(cGzipReader, "bytes", rb_gzreader_bytes, 0);
04456     rb_define_method(cGzipReader, "ungetc", rb_gzreader_ungetc, 1);
04457     rb_define_method(cGzipReader, "ungetbyte", rb_gzreader_ungetbyte, 1);
04458     rb_define_method(cGzipReader, "gets", rb_gzreader_gets, -1);
04459     rb_define_method(cGzipReader, "readline", rb_gzreader_readline, -1);
04460     rb_define_method(cGzipReader, "each", rb_gzreader_each, -1);
04461     rb_define_method(cGzipReader, "each_line", rb_gzreader_each, -1);
04462     rb_define_method(cGzipReader, "lines", rb_gzreader_lines, -1);
04463     rb_define_method(cGzipReader, "readlines", rb_gzreader_readlines, -1);
04464 
04465     /* The OS code of current host */
04466     rb_define_const(mZlib, "OS_CODE", INT2FIX(OS_CODE));
04467     /* OS code for MSDOS hosts */
04468     rb_define_const(mZlib, "OS_MSDOS", INT2FIX(OS_MSDOS));
04469     /* OS code for Amiga hosts */
04470     rb_define_const(mZlib, "OS_AMIGA", INT2FIX(OS_AMIGA));
04471     /* OS code for VMS hosts */
04472     rb_define_const(mZlib, "OS_VMS", INT2FIX(OS_VMS));
04473     /* OS code for UNIX hosts */
04474     rb_define_const(mZlib, "OS_UNIX", INT2FIX(OS_UNIX));
04475     /* OS code for Atari hosts */
04476     rb_define_const(mZlib, "OS_ATARI", INT2FIX(OS_ATARI));
04477     /* OS code for OS2 hosts */
04478     rb_define_const(mZlib, "OS_OS2", INT2FIX(OS_OS2));
04479     /* OS code for Mac OS hosts */
04480     rb_define_const(mZlib, "OS_MACOS", INT2FIX(OS_MACOS));
04481     /* OS code for TOPS-20 hosts */
04482     rb_define_const(mZlib, "OS_TOPS20", INT2FIX(OS_TOPS20));
04483     /* OS code for Win32 hosts */
04484     rb_define_const(mZlib, "OS_WIN32", INT2FIX(OS_WIN32));
04485     /* OS code for VM OS hosts */
04486     rb_define_const(mZlib, "OS_VMCMS", INT2FIX(OS_VMCMS));
04487     /* OS code for Z-System hosts */
04488     rb_define_const(mZlib, "OS_ZSYSTEM", INT2FIX(OS_ZSYSTEM));
04489     /* OS code for CP/M hosts */
04490     rb_define_const(mZlib, "OS_CPM", INT2FIX(OS_CPM));
04491     /* OS code for QDOS hosts */
04492     rb_define_const(mZlib, "OS_QDOS", INT2FIX(OS_QDOS));
04493     /* OS code for RISC OS hosts */
04494     rb_define_const(mZlib, "OS_RISCOS", INT2FIX(OS_RISCOS));
04495     /* OS code for unknown hosts */
04496     rb_define_const(mZlib, "OS_UNKNOWN", INT2FIX(OS_UNKNOWN));
04497 
04498 #endif /* GZIP_SUPPORT */
04499 }
04500 
04501 /* Document error classes. */
04502 
04503 /*
04504  * Document-class: Zlib::Error
04505  *
04506  * The superclass for all exceptions raised by Ruby/zlib.
04507  *
04508  * The following exceptions are defined as subclasses of Zlib::Error. These
04509  * exceptions are raised when zlib library functions return with an error
04510  * status.
04511  *
04512  * - Zlib::StreamEnd
04513  * - Zlib::NeedDict
04514  * - Zlib::DataError
04515  * - Zlib::StreamError
04516  * - Zlib::MemError
04517  * - Zlib::BufError
04518  * - Zlib::VersionError
04519  *
04520  */
04521 
04522 /*
04523  * Document-class: Zlib::StreamEnd
04524  *
04525  * Subclass of Zlib::Error
04526  *
04527  * When zlib returns a Z_STREAM_END
04528  * is return if the end of the compressed data has been reached
04529  * and all uncompressed out put has been produced.
04530  *
04531  */
04532 
04533 /*
04534  * Document-class: Zlib::NeedDict
04535  *
04536  * Subclass of Zlib::Error
04537  *
04538  * When zlib returns a Z_NEED_DICT
04539  * if a preset dictionary is needed at this point.
04540  *
04541  * Used by Zlib::Inflate.inflate and <tt>Zlib.inflate</tt>
04542  */
04543 
04544 /*
04545  * Document-class: Zlib::VersionError
04546  *
04547  * Subclass of Zlib::Error
04548  *
04549  * When zlib returns a Z_VERSION_ERROR,
04550  * usually if the zlib library version is incompatible with the
04551  * version assumed by the caller.
04552  *
04553  */
04554 
04555 /*
04556  * Document-class: Zlib::MemError
04557  *
04558  * Subclass of Zlib::Error
04559  *
04560  * When zlib returns a Z_MEM_ERROR,
04561  * usually if there was not enough memory.
04562  *
04563  */
04564 
04565 /*
04566  * Document-class: Zlib::StreamError
04567  *
04568  * Subclass of Zlib::Error
04569  *
04570  * When zlib returns a Z_STREAM_ERROR,
04571  * usually if the stream state was inconsistent.
04572  *
04573  */
04574 
04575 /*
04576  * Document-class: Zlib::BufError
04577  *
04578  * Subclass of Zlib::Error when zlib returns a Z_BUF_ERROR.
04579  *
04580  * Usually if no progress is possible.
04581  *
04582  */
04583 
04584 /*
04585  * Document-class: Zlib::DataError
04586  *
04587  * Subclass of Zlib::Error when zlib returns a Z_DATA_ERROR.
04588  *
04589  * Usually if a stream was prematurely freed.
04590  *
04591  */
04592 
04593 /*
04594  * Document-class: Zlib::GzipFile::Error
04595  *
04596  * Base class of errors that occur when processing GZIP files.
04597  */
04598 
04599 /*
04600  * Document-class: Zlib::GzipFile::NoFooter
04601  *
04602  * Raised when gzip file footer is not found.
04603  */
04604 
04605 /*
04606  * Document-class: Zlib::GzipFile::CRCError
04607  *
04608  * Raised when the CRC checksum recorded in gzip file footer is not equivalent
04609  * to the CRC checksum of the actual uncompressed data.
04610  */
04611 
04612 /*
04613  * Document-class: Zlib::GzipFile::LengthError
04614  *
04615  * Raised when the data length recorded in the gzip file footer is not equivalent
04616  * to the length of the actual uncompressed data.
04617  */
04618 
04619 
04620