15#ifdef HAVE_VALGRIND_MEMCHECK_H
16# include <valgrind/memcheck.h>
17# ifndef VALGRIND_MAKE_MEM_DEFINED
18# define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
20# ifndef VALGRIND_MAKE_MEM_UNDEFINED
21# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
24# define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
25# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
28#define RUBY_ZLIB_VERSION "2.0.0"
30#ifndef RB_PASS_CALLED_KEYWORDS
31# define rb_class_new_instance_kw(argc, argv, klass, kw_splat) rb_class_new_instance(argc, argv, klass)
41#define DEF_MEM_LEVEL 8
43#define DEF_MEM_LEVEL MAX_MEM_LEVEL
47#if SIZEOF_LONG > SIZEOF_INT
51 if (n > UINT_MAX) n = UINT_MAX;
54#define MAX_UINT(n) max_uint(n)
56#define MAX_UINT(n) (uInt)(n)
59#define OPTHASH_GIVEN_P(opts) \
60 (argc > 0 && !NIL_P((opts) = rb_check_hash_type(argv[argc-1])) && (--argc, 1))
62static ID id_dictionaries, id_read, id_buffer;
66static NORETURN(
void raise_zlib_error(
int,
const char*));
74static void finalizer_warn(
const char*);
79static void zstream_init(
struct zstream*,
const struct zstream_funcs*);
80static void zstream_expand_buffer(
struct zstream*);
81static void zstream_expand_buffer_into(
struct zstream*,
unsigned long);
82static int zstream_expand_buffer_non_stream(
struct zstream *
z);
83static void zstream_append_buffer(
struct zstream*,
const Bytef*,
long);
86static void zstream_buffer_ungets(
struct zstream*,
const Bytef*,
unsigned long);
87static void zstream_buffer_ungetbyte(
struct zstream*,
int);
88static void zstream_append_input(
struct zstream*,
const Bytef*,
long);
89static void zstream_discard_input(
struct zstream*,
long);
90static void zstream_reset_input(
struct zstream*);
91static void zstream_passthrough_input(
struct zstream*);
93static void zstream_reset(
struct zstream*);
96static void zstream_run(
struct zstream*,
Bytef*,
long,
int);
98static void zstream_mark(
void*);
99static void zstream_free(
void*);
100static VALUE zstream_new(
VALUE,
const struct zstream_funcs*);
102static void zstream_finalize(
struct zstream*);
144static void gzfile_mark(
void*);
145static void gzfile_free(
void*);
146static VALUE gzfile_new(
VALUE,
const struct zstream_funcs*,
void (*)
_((
struct gzfile*)));
147static void gzfile_reset(
struct gzfile*);
148static void gzfile_close(
struct gzfile*,
int);
149static void gzfile_write_raw(
struct gzfile*);
153static int gzfile_read_raw_ensure(
struct gzfile*,
long,
VALUE outbuf);
154static char *gzfile_read_raw_until_zero(
struct gzfile*,
long);
155static unsigned int gzfile_get16(
const unsigned char*);
156static unsigned long gzfile_get32(
const unsigned char*);
157static void gzfile_set32(
unsigned long n,
unsigned char*);
158static void gzfile_make_header(
struct gzfile*);
159static void gzfile_make_footer(
struct gzfile*);
160static void gzfile_read_header(
struct gzfile*,
VALUE outbuf);
161static void gzfile_check_footer(
struct gzfile*,
VALUE outbuf);
162static void gzfile_write(
struct gzfile*,
Bytef*,
long);
163static long gzfile_read_more(
struct gzfile*,
VALUE outbuf);
164static void gzfile_calc_crc(
struct gzfile*,
VALUE);
165static VALUE gzfile_read(
struct gzfile*,
long);
166static VALUE gzfile_read_all(
struct gzfile*);
167static void gzfile_ungets(
struct gzfile*,
const Bytef*,
long);
168static void gzfile_ungetbyte(
struct gzfile*,
int);
170static void gzfile_writer_end(
struct gzfile*);
172static void gzfile_reader_end(
struct gzfile*);
173static void gzfile_reader_rewind(
struct gzfile*);
174static VALUE gzfile_reader_get_unused(
struct gzfile*);
175static struct gzfile *get_gzfile(
VALUE);
179NORETURN(
static void gzfile_raise(
struct gzfile *,
VALUE,
const char *));
222static void gzreader_skip_linebreaks(
struct gzfile*);
307static VALUE cZError, cStreamEnd, cNeedDict;
308static VALUE cStreamError, cDataError, cMemError, cBufError, cVersionError, cInProgressError;
311raise_zlib_error(
int err,
const char *msg)
356finalizer_warn(
const char *msg)
358 fprintf(stderr,
"zlib(finalizer): %s\n", msg);
370rb_zlib_version(
VALUE klass)
375#if SIZEOF_LONG > SIZEOF_INT
379 if (
len > UINT_MAX) {
381 sum = func(sum,
ptr, UINT_MAX);
384 }
while (
len >= UINT_MAX);
390#define checksum_long(func, sum, ptr, len) (func)((sum), (ptr), (len))
412 sum = func(sum,
Z_NULL, 0);
456#ifdef HAVE_ADLER32_COMBINE
474#define rb_zlib_adler32_combine rb_f_notimplement
496#ifdef HAVE_CRC32_COMBINE
514#define rb_zlib_crc32_combine rb_f_notimplement
523rb_zlib_crc_table(
VALUE obj)
525#if !defined(HAVE_TYPE_Z_CRC_T)
536 for (i = 0; i < 256; i++) {
559#define ZSTREAM_FLAG_READY (1 << 0)
560#define ZSTREAM_FLAG_IN_STREAM (1 << 1)
561#define ZSTREAM_FLAG_FINISHED (1 << 2)
562#define ZSTREAM_FLAG_CLOSING (1 << 3)
563#define ZSTREAM_FLAG_GZFILE (1 << 4)
565#define ZSTREAM_REUSE_BUFFER (1 << 5)
566#define ZSTREAM_IN_PROGRESS (1 << 6)
567#define ZSTREAM_FLAG_UNUSED (1 << 7)
569#define ZSTREAM_READY(z) ((z)->flags |= ZSTREAM_FLAG_READY)
570#define ZSTREAM_IS_READY(z) ((z)->flags & ZSTREAM_FLAG_READY)
571#define ZSTREAM_IS_FINISHED(z) ((z)->flags & ZSTREAM_FLAG_FINISHED)
572#define ZSTREAM_IS_CLOSING(z) ((z)->flags & ZSTREAM_FLAG_CLOSING)
573#define ZSTREAM_IS_GZFILE(z) ((z)->flags & ZSTREAM_FLAG_GZFILE)
574#define ZSTREAM_BUF_FILLED(z) (NIL_P((z)->buf) ? 0 : RSTRING_LEN((z)->buf))
576#define ZSTREAM_REUSE_BUFFER_P(z) ((z)->flags & ZSTREAM_REUSE_BUFFER)
578#define ZSTREAM_EXPAND_BUFFER_OK 0
582#define ZSTREAM_INITIAL_BUFSIZE 1024
584#define ZSTREAM_AVAIL_OUT_STEP_MAX 16384
585#define ZSTREAM_AVAIL_OUT_STEP_MIN 2048
587static const struct zstream_funcs deflate_funcs = {
591static const struct zstream_funcs inflate_funcs = {
624zstream_init(
struct zstream *z,
const struct zstream_funcs *
func)
641#define zstream_init_deflate(z) zstream_init((z), &deflate_funcs)
642#define zstream_init_inflate(z) zstream_init((z), &inflate_funcs)
645zstream_expand_buffer(
struct zstream *z)
680 zstream_expand_buffer_into(z,
685 zstream_expand_buffer_non_stream(z);
690zstream_expand_buffer_into(
struct zstream *z,
unsigned long size)
708zstream_expand_buffer_protect(
void *
ptr)
719zstream_expand_buffer_non_stream(
struct zstream *z)
769#define zstream_append_buffer2(z,v) \
770 zstream_append_buffer((z),(Bytef*)RSTRING_PTR(v),RSTRING_LEN(v))
773zstream_detach_buffer(
struct zstream *z)
807zstream_shift_buffer(
struct zstream *z,
long len)
814 return zstream_detach_buffer(z);
833zstream_buffer_ungets(
struct zstream *z,
const Bytef *b,
unsigned long len)
839 zstream_expand_buffer_into(z,
len);
854zstream_buffer_ungetbyte(
struct zstream *z,
int c)
857 zstream_buffer_ungets(z, &cc, 1);
863 if (
len <= 0)
return;
875#define zstream_append_input2(z,v)\
877 zstream_append_input((z), (Bytef*)RSTRING_PTR(v), RSTRING_LEN(v))
880zstream_discard_input(
struct zstream *z,
long len)
890 newlen = oldlen -
len;
918zstream_reset_input(
struct zstream *z)
929zstream_passthrough_input(
struct zstream *z)
938zstream_detach_input(
struct zstream *z)
954zstream_reset(
struct zstream *z)
966 zstream_reset_input(z);
975 rb_warning(
"attempt to close uninitialized zstream; ignored.");
979 rb_warning(
"attempt to close unfinished zstream; reset forced.");
983 zstream_reset_input(z);
993zstream_ensure_end(
VALUE v)
995 return zstream_end((
struct zstream *)v);
999zstream_run_func(
void *
ptr)
1013 z->
flags &= ~ZSTREAM_FLAG_IN_STREAM;
1039 state = zstream_expand_buffer_non_stream(z);
1057zstream_unblock_func(
void *
ptr)
1065zstream_run_try(
VALUE value_arg)
1071 int flush = args->
flush;
1081 zstream_append_input(z, src,
len);
1085 old_input = zstream_detach_input(z);
1092 zstream_expand_buffer(z);
1096#ifndef RB_NOGVL_UBF_ASYNC_SAFE
1098 zstream_unblock_func, (
void *)args);
1101 zstream_unblock_func, (
void *)args,
1106 if (
err ==
Z_OK && args->interrupt) {
1107 args->interrupt = 0;
1116 zstream_reset_input(z);
1128 rb_inflate_set_dictionary(self, dict);
1139 if (!
NIL_P(old_input)) {
1144 if (args->jump_state)
1151zstream_run_ensure(
VALUE value_arg)
1156 args->
z->
flags &= ~ZSTREAM_IN_PROGRESS;
1162zstream_run_synchronized(
VALUE value_arg)
1168 rb_raise(cInProgressError,
"zlib stream is in progress");
1172 rb_ensure(zstream_run_try, value_arg, zstream_run_ensure, value_arg);
1203 zstream_discard_input(
z,
1205 zstream_append_input(
z,
src,
len);
1208 zstream_reset_input(
z);
1232zstream_mark(
void *p)
1241zstream_finalize(
struct zstream *z)
1245 finalizer_warn(
"the stream state was inconsistent.");
1247 finalizer_warn(
"the stream was freed prematurely.");
1251zstream_free(
void *p)
1256 zstream_finalize(z);
1262zstream_memsize(
const void *p)
1265 return sizeof(
struct zstream);
1270 { zstream_mark, zstream_free, zstream_memsize, },
1275zstream_new(
VALUE klass,
const struct zstream_funcs *funcs)
1281 zstream_init(z, funcs);
1286#define zstream_deflate_new(klass) zstream_new((klass), &deflate_funcs)
1287#define zstream_inflate_new(klass) zstream_new((klass), &inflate_funcs)
1290get_zstream(
VALUE obj)
1296 rb_raise(cZError,
"stream is not ready");
1370rb_zstream_end(
VALUE obj)
1372 zstream_end(get_zstream(obj));
1381rb_zstream_reset(
VALUE obj)
1383 zstream_reset(get_zstream(obj));
1397rb_zstream_finish(
VALUE obj)
1399 struct zstream *z = get_zstream(obj);
1403 return zstream_detach_buffer(z);
1412rb_zstream_flush_next_in(
VALUE obj)
1418 dst = zstream_detach_input(z);
1432rb_zstream_flush_next_out(
VALUE obj)
1438 return zstream_detach_buffer(z);
1446rb_zstream_avail_out(
VALUE obj)
1462 struct zstream *z = get_zstream(obj);
1472rb_zstream_avail_in(
VALUE obj)
1483rb_zstream_total_in(
VALUE obj)
1492rb_zstream_total_out(
VALUE obj)
1503rb_zstream_data_type(
VALUE obj)
1512rb_zstream_adler(
VALUE obj)
1521rb_zstream_finished_p(
VALUE obj)
1530rb_zstream_closed_p(
VALUE obj)
1547#define FIXNUMARG(val, ifnil) \
1548 (NIL_P((val)) ? (ifnil) \
1551#define ARG_LEVEL(val) FIXNUMARG((val), Z_DEFAULT_COMPRESSION)
1552#define ARG_WBITS(val) FIXNUMARG((val), MAX_WBITS)
1553#define ARG_MEMLEVEL(val) FIXNUMARG((val), DEF_MEM_LEVEL)
1554#define ARG_STRATEGY(val) FIXNUMARG((val), Z_DEFAULT_STRATEGY)
1555#define ARG_FLUSH(val) FIXNUMARG((val), Z_NO_FLUSH)
1559rb_deflate_s_allocate(
VALUE klass)
1641 VALUE level, wbits, memlevel, strategy;
1670 z2 = get_zstream(orig);
1672 if (z1 == z2)
return self;
1675 raise_zlib_error(
err, 0);
1685deflate_run(
VALUE args)
1691 return zstream_detach_buffer(z);
1721 VALUE src, level, dst, args[2];
1735 args[0] = (
VALUE)&z;
1784 struct zstream *z = get_zstream(obj);
1790 return zstream_detach_buffer(z);
1805 do_deflate(get_zstream(obj), src,
Z_NO_FLUSH);
1827 struct zstream *z = get_zstream(obj);
1834 zstream_run(z, (
Bytef*)
"", 0, flush);
1837 return zstream_detach_buffer(z);
1855 struct zstream *z = get_zstream(obj);
1856 int level, strategy;
1868 rb_warning(
"deflateParams() returned Z_BUF_ERROR");
1869 zstream_expand_buffer(z);
1898rb_deflate_set_dictionary(
VALUE obj,
VALUE dic)
1900 struct zstream *z = get_zstream(obj);
1926rb_inflate_s_allocate(
VALUE klass)
1998inflate_run(
VALUE args)
2005 return zstream_detach_buffer(z);
2046 args[0] = (
VALUE)&z;
2076rb_inflate_add_dictionary(
VALUE obj,
VALUE dictionary)
2135 struct zstream *z = get_zstream(obj);
2145 if (buffer !=
Qnil) {
2160 z->
flags &= ~ZSTREAM_REUSE_BUFFER;
2167 dst = zstream_detach_buffer(z);
2181 dst = zstream_detach_buffer(z);
2183 zstream_passthrough_input(z);
2200 struct zstream *z = get_zstream(obj);
2211 zstream_passthrough_input(z);
2229 struct zstream *z = get_zstream(obj);
2243rb_inflate_sync_point_p(
VALUE obj)
2245 struct zstream *z = get_zstream(obj);
2266rb_inflate_set_dictionary(
VALUE obj,
VALUE dic)
2268 struct zstream *z = get_zstream(obj);
2293#define GZ_MAGIC1 0x1f
2294#define GZ_MAGIC2 0x8b
2295#define GZ_METHOD_DEFLATE 8
2296#define GZ_FLAG_MULTIPART 0x2
2297#define GZ_FLAG_EXTRA 0x4
2298#define GZ_FLAG_ORIG_NAME 0x8
2299#define GZ_FLAG_COMMENT 0x10
2300#define GZ_FLAG_ENCRYPT 0x20
2301#define GZ_FLAG_UNKNOWN_MASK 0xc0
2303#define GZ_EXTRAFLAG_FAST 0x4
2304#define GZ_EXTRAFLAG_SLOW 0x2
2307#define OS_MSDOS 0x00
2308#define OS_AMIGA 0x01
2311#define OS_ATARI 0x05
2313#define OS_MACOS 0x07
2314#define OS_TOPS20 0x0a
2315#define OS_WIN32 0x0b
2317#define OS_VMCMS 0x04
2318#define OS_ZSYSTEM 0x08
2321#define OS_RISCOS 0x0d
2322#define OS_UNKNOWN 0xff
2325#define OS_CODE OS_UNIX
2328static ID id_write, id_readpartial, id_flush, id_seek, id_close, id_path, id_input;
2329static VALUE cGzError, cNoFooter, cCRCError, cLengthError;
2347 void (*end)(
struct gzfile *);
2354#define GZFILE_CBUF_CAPA 10
2356#define GZFILE_FLAG_SYNC ZSTREAM_FLAG_UNUSED
2357#define GZFILE_FLAG_HEADER_FINISHED (ZSTREAM_FLAG_UNUSED << 1)
2358#define GZFILE_FLAG_FOOTER_FINISHED (ZSTREAM_FLAG_UNUSED << 2)
2359#define GZFILE_FLAG_MTIME_IS_SET (ZSTREAM_FLAG_UNUSED << 3)
2361#define GZFILE_IS_FINISHED(gz) \
2362 (ZSTREAM_IS_FINISHED(&(gz)->z) && ZSTREAM_BUF_FILLED(&(gz)->z) == 0)
2364#define GZFILE_READ_SIZE 2048
2366struct read_raw_arg {
2380 struct gzfile *gz = p;
2385 zstream_mark(&gz->z);
2393 struct gzfile *gz = p;
2397 if (z->
func == &deflate_funcs) {
2398 finalizer_warn(
"Zlib::GzipWriter object must be closed explicitly.");
2400 zstream_finalize(z);
2406gzfile_memsize(
const void *p)
2408 return sizeof(
struct gzfile);
2413 { gzfile_mark, gzfile_free, gzfile_memsize, },
2418gzfile_init(
struct gzfile *gz,
const struct zstream_funcs *funcs,
void (*endfunc)(
struct gzfile *))
2420 zstream_init(&gz->z, funcs);
2426 gz->orig_name =
Qnil;
2441gzfile_new(
VALUE klass,
const struct zstream_funcs *funcs,
void (*endfunc)(
struct gzfile *))
2447 gzfile_init(gz, funcs, endfunc);
2451#define gzfile_writer_new(gz) gzfile_new((gz),&deflate_funcs,gzfile_writer_end)
2452#define gzfile_reader_new(gz) gzfile_new((gz),&inflate_funcs,gzfile_reader_end)
2455gzfile_reset(
struct gzfile *gz)
2457 zstream_reset(&gz->z);
2465 gz->ecflags, gz->ecopts);
2470gzfile_close(
struct gzfile *gz,
int closeflag)
2476 gz->orig_name =
Qnil;
2484gzfile_write_raw(
struct gzfile *gz)
2489 str = zstream_detach_buffer(&gz->z);
2491 if ((gz->z.flags & GZFILE_FLAG_SYNC)
2498gzfile_read_raw_partial(
VALUE arg)
2500 struct read_raw_arg *ra = (
struct read_raw_arg *)arg;
2502 int argc =
NIL_P(ra->as.argv[1]) ? 1 : 2;
2512 struct read_raw_arg *ra = (
struct read_raw_arg *)arg;
2515 int argc =
NIL_P(ra->as.argv[1]) ? 1 : 2;
2527 struct read_raw_arg ra;
2530 ra.as.in.len =
INT2FIX(GZFILE_READ_SIZE);
2534 gzfile_read_raw_rescue, (
VALUE)&ra,
2545 rb_raise(cGzError,
"unexpected end of string");
2556gzfile_read_raw_until_zero(
struct gzfile *gz,
long offset)
2565 str = gzfile_read_raw(gz,
Qnil);
2567 rb_raise(cGzError,
"unexpected end of file");
2576gzfile_get16(
const unsigned char *src)
2579 n = *(src++) & 0xff;
2580 n |= (*(src++) & 0xff) << 8;
2585gzfile_get32(
const unsigned char *src)
2588 n = *(src++) & 0xff;
2589 n |= (*(src++) & 0xff) << 8;
2590 n |= (*(src++) & 0xff) << 16;
2591 n |= (*(src++) & 0xffU) << 24;
2596gzfile_set32(
unsigned long n,
unsigned char *dst)
2598 *(dst++) = n & 0xff;
2599 *(dst++) = (n >> 8) & 0xff;
2600 *(dst++) = (n >> 16) & 0xff;
2601 *dst = (n >> 24) & 0xff;
2605gzfile_raise(
struct gzfile *gz,
VALUE klass,
const char *message)
2608 if (!
NIL_P(gz->z.input)) {
2635gzfile_make_header(
struct gzfile *gz)
2638 unsigned char flags = 0, extraflags = 0;
2640 if (!
NIL_P(gz->orig_name)) {
2641 flags |= GZ_FLAG_ORIG_NAME;
2643 if (!
NIL_P(gz->comment)) {
2644 flags |= GZ_FLAG_COMMENT;
2646 if (!(gz->z.flags & GZFILE_FLAG_MTIME_IS_SET)) {
2647 gz->mtime = time(0);
2651 extraflags |= GZ_EXTRAFLAG_FAST;
2654 extraflags |= GZ_EXTRAFLAG_SLOW;
2659 buf[2] = GZ_METHOD_DEFLATE;
2661 gzfile_set32((
unsigned long)gz->mtime, &
buf[4]);
2662 buf[8] = extraflags;
2663 buf[9] = gz->os_code;
2664 zstream_append_buffer(&gz->z,
buf, (
long)
sizeof(
buf));
2666 if (!
NIL_P(gz->orig_name)) {
2668 zstream_append_buffer(&gz->z, (
Bytef*)
"\0", 1);
2670 if (!
NIL_P(gz->comment)) {
2672 zstream_append_buffer(&gz->z, (
Bytef*)
"\0", 1);
2675 gz->z.flags |= GZFILE_FLAG_HEADER_FINISHED;
2679gzfile_make_footer(
struct gzfile *gz)
2683 gzfile_set32(gz->crc,
buf);
2684 gzfile_set32(gz->z.stream.total_in, &
buf[4]);
2685 zstream_append_buffer(&gz->z,
buf, (
long)
sizeof(
buf));
2686 gz->z.flags |= GZFILE_FLAG_FOOTER_FINISHED;
2690gzfile_read_header(
struct gzfile *gz,
VALUE outbuf)
2692 const unsigned char *head;
2697 if (!gzfile_read_raw_ensure(gz, 10,
outbuf)) {
2698 gzfile_raise(gz, cGzError,
"not in gzip format");
2703 if (head[0] != GZ_MAGIC1 || head[1] != GZ_MAGIC2) {
2704 gzfile_raise(gz, cGzError,
"not in gzip format");
2706 if (head[2] != GZ_METHOD_DEFLATE) {
2707 rb_raise(cGzError,
"unsupported compression method %d", head[2]);
2711 if (flags & GZ_FLAG_MULTIPART) {
2712 rb_raise(cGzError,
"multi-part gzip file is not supported");
2714 else if (flags & GZ_FLAG_ENCRYPT) {
2715 rb_raise(cGzError,
"encrypted gzip file is not supported");
2717 else if (flags & GZ_FLAG_UNKNOWN_MASK) {
2718 rb_raise(cGzError,
"unknown flags 0x%02x", flags);
2721 if (head[8] & GZ_EXTRAFLAG_FAST) {
2724 else if (head[8] & GZ_EXTRAFLAG_SLOW) {
2731 gz->mtime = gzfile_get32(&head[4]);
2732 gz->os_code = head[9];
2733 zstream_discard_input(&gz->z, 10);
2735 if (flags & GZ_FLAG_EXTRA) {
2736 if (!gzfile_read_raw_ensure(gz, 2,
outbuf)) {
2737 rb_raise(cGzError,
"unexpected end of file");
2740 if (!gzfile_read_raw_ensure(gz, 2 +
len,
outbuf)) {
2741 rb_raise(cGzError,
"unexpected end of file");
2743 zstream_discard_input(&gz->z, 2 +
len);
2745 if (flags & GZ_FLAG_ORIG_NAME) {
2746 if (!gzfile_read_raw_ensure(gz, 1,
outbuf)) {
2747 rb_raise(cGzError,
"unexpected end of file");
2749 p = gzfile_read_raw_until_zero(gz, 0);
2752 zstream_discard_input(&gz->z,
len + 1);
2754 if (flags & GZ_FLAG_COMMENT) {
2755 if (!gzfile_read_raw_ensure(gz, 1,
outbuf)) {
2756 rb_raise(cGzError,
"unexpected end of file");
2758 p = gzfile_read_raw_until_zero(gz, 0);
2761 zstream_discard_input(&gz->z,
len + 1);
2770gzfile_check_footer(
struct gzfile *gz,
VALUE outbuf)
2772 unsigned long crc, length;
2774 gz->z.flags |= GZFILE_FLAG_FOOTER_FINISHED;
2777 if (!gzfile_read_raw_ensure(gz, 8,
outbuf)) {
2778 gzfile_raise(gz, cNoFooter,
"footer is not found");
2784 gz->z.stream.total_in += 8;
2785 zstream_discard_input(&gz->z, 8);
2787 if (gz->crc != crc) {
2788 rb_raise(cCRCError,
"invalid compressed data -- crc error");
2790 if ((
uint32_t)gz->z.stream.total_out != length) {
2791 rb_raise(cLengthError,
"invalid compressed data -- length error");
2796gzfile_write(
struct gzfile *gz,
Bytef *
str,
long len)
2798 if (!(gz->z.flags & GZFILE_FLAG_HEADER_FINISHED)) {
2799 gzfile_make_header(gz);
2802 if (
len > 0 || (gz->z.flags & GZFILE_FLAG_SYNC)) {
2804 zstream_run(&gz->z,
str,
len, (gz->z.flags & GZFILE_FLAG_SYNC)
2807 gzfile_write_raw(gz);
2819 rb_raise(cGzError,
"unexpected end of file");
2834gzfile_calc_crc(
struct gzfile *gz,
VALUE str)
2847gzfile_newstr(
struct gzfile *gz,
VALUE str)
2859 gz->ecflags, gz->ecopts);
2863gzfile_fill(
struct gzfile *gz,
long len)
2870 gzfile_read_more(gz,
Qnil);
2872 if (GZFILE_IS_FINISHED(gz)) {
2873 if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2874 gzfile_check_footer(gz,
Qnil);
2882gzfile_read(
struct gzfile *gz,
long len)
2886 len = gzfile_fill(gz,
len);
2889 dst = zstream_shift_buffer(&gz->z,
len);
2890 if (!
NIL_P(dst)) gzfile_calc_crc(gz, dst);
2911 gzfile_read_more(gz,
outbuf);
2913 if (GZFILE_IS_FINISHED(gz)) {
2914 if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2915 gzfile_check_footer(gz,
outbuf);
2922 dst = zstream_shift_buffer(&gz->z,
len);
2923 gzfile_calc_crc(gz, dst);
2936gzfile_read_all(
struct gzfile *gz)
2941 gzfile_read_more(gz,
Qnil);
2943 if (GZFILE_IS_FINISHED(gz)) {
2944 if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2945 gzfile_check_footer(gz,
Qnil);
2950 dst = zstream_detach_buffer(&gz->z);
2951 if (
NIL_P(dst))
return dst;
2952 gzfile_calc_crc(gz, dst);
2953 return gzfile_newstr(gz, dst);
2957gzfile_getc(
struct gzfile *gz)
2964 gzfile_read_more(gz,
Qnil);
2966 if (GZFILE_IS_FINISHED(gz)) {
2967 if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2968 gzfile_check_footer(gz,
Qnil);
2974 const unsigned char *ss, *sp, *se;
2975 unsigned char *ds, *
dp, *de;
2978 ss = sp = (
const unsigned char*)
RSTRING_PTR(gz->z.buf);
2981 de = (
unsigned char *)ds + GZFILE_CBUF_CAPA;
2984 dst = zstream_shift_buffer(&gz->z, sp - ss);
2985 gzfile_calc_crc(gz, dst);
2992 dst = gzfile_read(gz,
len);
2993 if (
NIL_P(dst))
return dst;
2994 return gzfile_newstr(gz, dst);
2999gzfile_ungets(
struct gzfile *gz,
const Bytef *b,
long len)
3001 zstream_buffer_ungets(&gz->z, b,
len);
3006gzfile_ungetbyte(
struct gzfile *gz,
int c)
3008 zstream_buffer_ungetbyte(&gz->z, c);
3013gzfile_writer_end_run(
VALUE arg)
3015 struct gzfile *gz = (
struct gzfile *)arg;
3017 if (!(gz->z.flags & GZFILE_FLAG_HEADER_FINISHED)) {
3018 gzfile_make_header(gz);
3022 gzfile_make_footer(gz);
3023 gzfile_write_raw(gz);
3029gzfile_writer_end(
struct gzfile *gz)
3038gzfile_reader_end_run(
VALUE arg)
3040 struct gzfile *gz = (
struct gzfile *)arg;
3042 if (GZFILE_IS_FINISHED(gz)
3043 && !(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
3044 gzfile_check_footer(gz,
Qnil);
3051gzfile_reader_end(
struct gzfile *gz)
3060gzfile_reader_rewind(
struct gzfile *gz)
3064 n = gz->z.stream.total_in;
3065 if (!
NIL_P(gz->z.input)) {
3074gzfile_reader_get_unused(
struct gzfile *gz)
3079 if (!GZFILE_IS_FINISHED(gz))
return Qnil;
3080 if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
3081 gzfile_check_footer(gz,
Qnil);
3089static struct gzfile *
3090get_gzfile(
VALUE obj)
3096 rb_raise(cGzError,
"closed gzip stream");
3151 new_wrap_arg_t *arg = (new_wrap_arg_t *)tmp;
3156gzfile_ensure_close(
VALUE obj)
3162 gzfile_close(gz, 1);
3172 if (close_io_on_error) {
3214 return gzfile_wrap(
argc,
argv, klass, 0);
3231 return gzfile_wrap(
argc,
argv, klass, 1);
3240rb_gzfile_to_io(
VALUE obj)
3242 return get_gzfile(obj)->io;
3251rb_gzfile_crc(
VALUE obj)
3262rb_gzfile_mtime(
VALUE obj)
3264 return rb_time_new(get_gzfile(obj)->mtime, (time_t)0);
3273rb_gzfile_level(
VALUE obj)
3275 return INT2FIX(get_gzfile(obj)->level);
3284rb_gzfile_os_code(
VALUE obj)
3286 return INT2FIX(get_gzfile(obj)->os_code);
3296rb_gzfile_orig_name(
VALUE obj)
3298 VALUE str = get_gzfile(obj)->orig_name;
3312rb_gzfile_comment(
VALUE obj)
3314 VALUE str = get_gzfile(obj)->comment;
3327rb_gzfile_lineno(
VALUE obj)
3329 return INT2NUM(get_gzfile(obj)->lineno);
3340 struct gzfile *gz = get_gzfile(obj);
3367 struct gzfile *gz = get_gzfile(obj);
3370 if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
3371 rb_raise(cGzError,
"header is already written");
3376 gz->z.flags |= GZFILE_FLAG_MTIME_IS_SET;
3389 struct gzfile *gz = get_gzfile(obj);
3393 if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
3394 rb_raise(cGzError,
"header is already written");
3413 struct gzfile *gz = get_gzfile(obj);
3417 if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
3418 rb_raise(cGzError,
"header is already written");
3436rb_gzfile_close(
VALUE obj)
3446 gzfile_close(gz, 1);
3458rb_gzfile_finish(
VALUE obj)
3460 struct gzfile *gz = get_gzfile(obj);
3464 gzfile_close(gz, 0);
3475rb_gzfile_closed_p(
VALUE obj)
3488rb_gzfile_eof_p(
VALUE obj)
3490 struct gzfile *gz = get_gzfile(obj);
3501rb_gzfile_sync(
VALUE obj)
3518 struct gzfile *gz = get_gzfile(obj);
3521 gz->z.flags |= GZFILE_FLAG_SYNC;
3524 gz->z.flags &= ~GZFILE_FLAG_SYNC;
3535rb_gzfile_total_in(
VALUE obj)
3546rb_gzfile_total_out(
VALUE obj)
3548 struct gzfile *gz = get_gzfile(obj);
3549 uLong total_out = gz->z.stream.total_out;
3552 if (total_out >= (
uLong)buf_filled) {
3555 return LONG2FIX(-(buf_filled - (
long)total_out));
3568rb_gzfile_path(
VALUE obj)
3576gzfile_initialize_path_partial(
VALUE obj)
3586rb_gzfile_ecopts(
struct gzfile *gz,
VALUE opts)
3635rb_gzwriter_s_allocate(
VALUE klass)
3637 return gzfile_writer_new(klass);
3650 return gzfile_s_open(
argc,
argv, klass,
"wb");
3686 raise_zlib_error(
err, gz->z.stream.msg);
3690 rb_gzfile_ecopts(gz, opt);
3710 struct gzfile *gz = get_gzfile(obj);
3718 zstream_run(&gz->z, (
Bytef*)
"", 0, flush);
3721 gzfile_write_raw(gz);
3734 struct gzfile *gz = get_gzfile(obj);
3737 while (
argc-- > 0) {
3757 struct gzfile *gz = get_gzfile(obj);
3760 gzfile_write(gz, (
Bytef*)&c, 1);
3770#define rb_gzwriter_addstr rb_io_addstr
3775#define rb_gzwriter_printf rb_io_printf
3780#define rb_gzwriter_print rb_io_print
3785#define rb_gzwriter_puts rb_io_puts
3843rb_gzreader_s_allocate(
VALUE klass)
3845 return gzfile_reader_new(klass);
3860 return gzfile_s_open(
argc,
argv, klass,
"rb");
3882 VALUE io, unused, obj,
buf=0, tmpbuf;
3891 rb_gzreader_each(0, 0, obj);
3897 tmpbuf = gzfile_read_all(get_gzfile(obj));
3901 rb_gzreader_read(0, 0, obj);
3903 unused = rb_gzreader_unused(obj);
3904 rb_gzfile_finish(obj);
3905 if (!
NIL_P(unused)) {
3947 raise_zlib_error(
err, gz->z.stream.msg);
3951 gzfile_read_header(gz,
Qnil);
3952 rb_gzfile_ecopts(gz, opt);
3969rb_gzreader_rewind(
VALUE obj)
3971 struct gzfile *gz = get_gzfile(obj);
3972 gzfile_reader_rewind(gz);
3983rb_gzreader_unused(
VALUE obj)
3987 return gzfile_reader_get_unused(gz);
3998 struct gzfile *gz = get_gzfile(obj);
4004 return gzfile_read_all(gz);
4011 return gzfile_read(gz,
len);
4029 struct gzfile *gz = get_gzfile(obj);
4041 return gzfile_readpartial(gz,
len,
outbuf);
4050rb_gzreader_getc(
VALUE obj)
4052 struct gzfile *gz = get_gzfile(obj);
4054 return gzfile_getc(gz);
4063rb_gzreader_readchar(
VALUE obj)
4066 dst = rb_gzreader_getc(obj);
4079rb_gzreader_getbyte(
VALUE obj)
4081 struct gzfile *gz = get_gzfile(obj);
4084 dst = gzfile_read(gz, 1);
4097rb_gzreader_readbyte(
VALUE obj)
4100 dst = rb_gzreader_getbyte(obj);
4113rb_gzreader_each_char(
VALUE obj)
4119 while (!
NIL_P(c = rb_gzreader_getc(obj))) {
4131rb_gzreader_each_byte(
VALUE obj)
4137 while (!
NIL_P(c = rb_gzreader_getbyte(obj))) {
4154 return rb_gzreader_ungetbyte(obj, s);
4155 gz = get_gzfile(obj);
4173 struct gzfile *gz = get_gzfile(obj);
4174 gzfile_ungetbyte(gz,
NUM2CHR(ch));
4179gzreader_skip_linebreaks(
struct gzfile *gz)
4186 if (GZFILE_IS_FINISHED(gz))
return;
4187 gzfile_read_more(gz,
Qnil);
4192 while (n++, *(p++) ==
'\n') {
4194 str = zstream_detach_buffer(&gz->z);
4195 gzfile_calc_crc(gz,
str);
4197 if (GZFILE_IS_FINISHED(gz))
return;
4198 gzfile_read_more(gz,
Qnil);
4205 str = zstream_shift_buffer(&gz->z, n - 1);
4206 gzfile_calc_crc(gz,
str);
4210rscheck(
const char *rsptr,
long rslen,
VALUE rs)
4217gzreader_charboundary(
struct gzfile *gz,
long n)
4240 struct gzfile *gz = get_gzfile(obj);
4245 long rslen, n, limit = -1;
4260 else if (!
NIL_P(rs)) {
4278 dst = gzfile_read_all(gz);
4281 else if ((n = gzfile_fill(gz, limit)) <= 0) {
4285 if (maxlen > 1 && n >= limit && !GZFILE_IS_FINISHED(gz)) {
4286 n = gzreader_charboundary(gz, n);
4291 dst = zstream_shift_buffer(&gz->z, n);
4292 if (
NIL_P(dst))
return dst;
4293 gzfile_calc_crc(gz, dst);
4294 dst = gzfile_newstr(gz, dst);
4312 gzreader_skip_linebreaks(gz);
4318 return gzfile_read(gz, rslen);
4320 gzfile_read_more(gz,
Qnil);
4329 gzfile_read_more(gz,
Qnil);
4332 if (!rspara) rscheck(rsptr, rslen, rs);
4334 if (limit > 0 && filled >= limit) {
4337 res = memchr(p, rsptr[0], (filled - n + 1));
4340 if (limit > 0 && filled >= limit)
break;
4344 n += (
long)(res - p);
4346 if (rslen == 1 ||
memcmp(p, rsptr, rslen) == 0)
break;
4351 n = gzreader_charboundary(gz, n);
4355 dst = gzfile_read(gz, n);
4356 if (
NIL_P(dst))
return dst;
4358 gzreader_skip_linebreaks(gz);
4362 return gzfile_newstr(gz, dst);
4376 dst = gzreader_gets(
argc,
argv, obj);
4392 dst = rb_gzreader_gets(
argc,
argv, obj);
4439rb_gzreader_external_encoding(
VALUE self)
4445zlib_gzip_end_rescue(
VALUE arg)
4447 struct gzfile *gz = (
struct gzfile *)arg;
4453zlib_gzip_ensure(
VALUE arg)
4459zlib_gzip_end(
struct gzfile *gz)
4463 gzfile_make_footer(gz);
4464 zstream_end(&gz->z);
4467static ID id_level, id_strategy;
4496 struct gzfile *gz = &gz0;
4503 keyword_ids[0] = id_level;
4504 keyword_ids[1] = id_strategy;
4506 if (kwargs[0] !=
Qundef) {
4509 if (kwargs[1] !=
Qundef) {
4510 strategy = kwargs[1];
4515 gzfile_init(gz, &deflate_funcs, zlib_gzip_end);
4521 raise_zlib_error(
err, gz->z.stream.msg);
4524 args[0] = (
VALUE)gz;
4530zlib_gzip_run(
VALUE arg)
4533 struct gzfile *gz = (
struct gzfile *)args[0];
4534 VALUE src = args[1];
4537 gzfile_make_header(gz);
4544 gzfile_close(gz, 0);
4545 return zstream_detach_buffer(&gz->z);
4549zlib_gunzip_end(
struct gzfile *gz)
4552 zstream_end(&gz->z);
4579 struct gzfile *gz = &gz0;
4584 gzfile_init(gz, &inflate_funcs, zlib_gunzip_end);
4587 raise_zlib_error(
err, gz->z.stream.msg);
4596zlib_gunzip_run(
VALUE arg)
4598 struct gzfile *gz = (
struct gzfile *)arg;
4601 gzfile_read_header(gz,
Qnil);
4602 dst = zstream_detach_buffer(&gz->z);
4603 gzfile_calc_crc(gz, dst);
4605 rb_raise(cGzError,
"unexpected end of file");
4607 if (
NIL_P(gz->z.input)) {
4608 rb_raise(cNoFooter,
"footer is not found");
4610 gzfile_check_footer(gz,
Qnil);
4619#ifdef HAVE_RB_EXT_RACTOR_SAFE
4624 VALUE mZlib, cZStream, cDeflate, cInflate;
4626 VALUE cGzipFile, cGzipWriter, cGzipReader;
4631 id_dictionaries =
rb_intern(
"@dictionaries");
4673 rb_define_method(cZStream,
"flush_next_out", rb_zstream_flush_next_out, 0);
4710 rb_define_method(cDeflate,
"set_dictionary", rb_deflate_set_dictionary, 1);
4717 rb_define_method(cInflate,
"add_dictionary", rb_inflate_add_dictionary, 1);
4722 rb_define_method(cInflate,
"set_dictionary", rb_inflate_set_dictionary, 1);
4807 id_readpartial =
rb_intern(
"readpartial");
4887 rb_define_method(cGzipReader,
"external_encoding", rb_gzreader_external_encoding, 0);
uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len)
uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, z_off_t len2)
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE rb_int2inum(intptr_t n)
VALUE rb_uint2inum(uintptr_t n)
const z_crc_t FAR *ZEXPORT get_crc_table()
uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2)
unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, uInt len)
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define rb_define_module_function(klass, mid, func, arity)
Defines klass#mid and makes it a module function.
int ZEXPORT deflateCopy(z_streamp dest, z_streamp source)
int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
int ZEXPORT deflateReset(z_streamp strm)
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
int ZEXPORT deflateEnd(z_streamp strm)
int ZEXPORT deflate(z_streamp strm, int flush)
int rb_enc_dummy_p(rb_encoding *enc)
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc)
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
rb_encoding * rb_ascii8bit_encoding(void)
rb_encoding * rb_enc_get(VALUE obj)
rb_encoding * rb_default_external_encoding(void)
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
VALUE rb_enc_from_encoding(rb_encoding *encoding)
char str[HTML_ESCAPE_MAX_LEN+1]
#define RSTRING_LEN(string)
#define RSTRING_PTR(string)
void rb_gc_force_recycle(VALUE obj)
void rb_gc_mark(VALUE ptr)
void rb_include_module(VALUE klass, VALUE module)
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
VALUE rb_define_module(const char *name)
void rb_define_attr(VALUE klass, const char *name, int read, int write)
Defines (a) public accessor method(s) for an attribute.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_rescue2(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*r_proc)(VALUE, VALUE), VALUE data2,...)
An equivalent of rescue clause.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *pstate)
Protects a function call from potential global escapes from the function.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
VALUE rb_rescue(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*r_proc)(VALUE, VALUE), VALUE data2)
An equivalent of rescue clause.
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
VALUE rb_errinfo(void)
The current exception in the current thread.
void rb_jump_tag(int tag)
Continues the exception caught by rb_protect() and rb_eval_string_protect().
void rb_sys_fail(const char *mesg)
void rb_warning(const char *fmt,...)
VALUE rb_obj_reveal(VALUE obj, VALUE klass)
Make a hidden object visible again.
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
Tries to convert an object into another type.
VALUE rb_cObject
Object class.
VALUE rb_class_new_instance_kw(int, const VALUE *, VALUE, int)
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_Integer(VALUE)
Equivalent to Kernel#Integer in Ruby.
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Determines if obj is a kind of c.
unsigned char outbuf[SIZE]
unsigned in(void *in_desc, z_const unsigned char **buf)
VALUE rb_hash_aref(VALUE hash, VALUE key)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
#define ECONV_AFTER_OUTPUT
int rb_econv_prepare_opts(VALUE opthash, VALUE *ecopts)
VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
#define rb_enc_left_char_head(s, p, e, enc)
rb_econv_result_t rb_econv_convert(rb_econv_t *ec, const unsigned char **source_buffer_ptr, const unsigned char *source_buffer_end, unsigned char **destination_buffer_ptr, unsigned char *destination_buffer_end, int flags)
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts)
#define MBCLEN_NEEDMORE_LEN(ret)
#define rb_enc_mbmaxlen(enc)
VALUE rb_econv_str_convert(rb_econv_t *ec, VALUE src, int flags)
rb_econv_t * rb_econv_open_opts(const char *source_encoding, const char *destination_encoding, int ecflags, VALUE ecopts)
#define MBCLEN_CHARFOUND_LEN(ret)
void rb_econv_check_error(rb_econv_t *ec)
#define MBCLEN_NEEDMORE_P(ret)
#define ECONV_PARTIAL_INPUT
#define MBCLEN_CHARFOUND_P(ret)
void rb_econv_close(rb_econv_t *ec)
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
VALUE rb_call_super(int, const VALUE *)
#define RETURN_ENUMERATOR(obj, argc, argv)
#define UNLIMITED_ARGUMENTS
VALUE rb_file_open_str(VALUE, const char *)
void rb_ext_ractor_safe(bool flag)
void rb_lastline_set(VALUE)
VALUE rb_str_resize(VALUE, long)
#define rb_str_new(str, len)
VALUE rb_str_cat(VALUE, const char *, long)
void rb_str_set_len(VALUE, long)
VALUE rb_str_substr(VALUE, long, long)
void rb_str_modify(VALUE)
VALUE rb_str_buf_new(long)
VALUE rb_check_string_type(VALUE)
VALUE rb_str_resurrect(VALUE str)
VALUE rb_str_inspect(VALUE)
VALUE rb_str_append(VALUE, VALUE)
void rb_str_modify_expand(VALUE, long)
VALUE rb_obj_as_string(VALUE)
size_t rb_str_capacity(VALUE)
VALUE rb_mutex_synchronize(VALUE mutex, VALUE(*func)(VALUE arg), VALUE arg)
VALUE rb_mutex_unlock(VALUE mutex)
VALUE rb_mutex_lock(VALUE mutex)
VALUE rb_time_new(time_t, long)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_attr_get(VALUE, ID)
VALUE rb_ivar_set(VALUE, ID, VALUE)
int rb_respond_to(VALUE, ID)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
void rb_undef_alloc_func(VALUE)
ID rb_intern(const char *)
void rb_define_const(VALUE, const char *, VALUE)
int rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p, int *fmode_p)
void * memmove(void *, const void *, size_t)
#define RB_NOGVL_UBF_ASYNC_SAFE
void * rb_nogvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2, int flags)
void * rb_thread_call_with_gvl(void *(*func)(void *), void *data1)
void * rb_thread_call_without_gvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2)
int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
int ZEXPORT inflateSyncPoint(z_streamp strm)
int ZEXPORT inflateSync(z_streamp strm)
int ZEXPORT inflate(z_streamp strm, int flush)
int ZEXPORT inflateReset(z_streamp strm)
int ZEXPORT inflateEnd(z_streamp strm)
typedef long(ZCALLBACK *tell_file_func) OF((voidpf opaque
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
int memcmp(const void *s1, const void *s2, size_t len)
VALUE rb_str_to_str(VALUE)
#define RSTRING_GETMEM(str, ptrvar, lenvar)
#define TypedData_Get_Struct(obj, type, data_type, sval)
@ RUBY_TYPED_FREE_IMMEDIATELY
#define TypedData_Make_Struct(klass, type, data_type, sval)
#define RB_PASS_CALLED_KEYWORDS
VALUE rb_sprintf(const char *,...)
int(* run)(z_streamp, int)
const struct zstream::zstream_funcs * func
void error(const char *msg)
if((ID)(DISPID) nameid !=nameid)
#define RUBY_ZLIB_VERSION
#define rb_zlib_crc32_combine
#define ZSTREAM_IS_READY(z)
#define ZSTREAM_REUSE_BUFFER
#define zstream_append_input2(z, v)
#define VALGRIND_MAKE_MEM_DEFINED(p, n)
#define ZSTREAM_BUF_FILLED(z)
#define rb_zlib_adler32_combine
#define zstream_append_buffer2(z, v)
#define ZSTREAM_FLAG_IN_STREAM
#define zstream_init_deflate(z)
#define zstream_init_inflate(z)
#define zstream_deflate_new(klass)
#define ZSTREAM_FLAG_READY
#define ZSTREAM_INITIAL_BUFSIZE
#define ZSTREAM_IS_GZFILE(z)
#define checksum_long(func, sum, ptr, len)
#define ARG_MEMLEVEL(val)
#define ZSTREAM_IN_PROGRESS
#define ZSTREAM_FLAG_FINISHED
#define ZSTREAM_AVAIL_OUT_STEP_MAX
#define ZSTREAM_FLAG_GZFILE
#define ZSTREAM_IS_FINISHED(z)
#define OPTHASH_GIVEN_P(opts)
#define ZSTREAM_AVAIL_OUT_STEP_MIN
#define ZSTREAM_REUSE_BUFFER_P(z)
#define ZSTREAM_FLAG_CLOSING
#define FIXNUMARG(val, ifnil)
#define zstream_inflate_new(klass)
#define ZSTREAM_IS_CLOSING(z)
#define ZSTREAM_EXPAND_BUFFER_OK
#define ARG_STRATEGY(val)
#define Z_DEFAULT_STRATEGY
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy)
#define inflateInit2(strm, windowBits)
#define Z_BEST_COMPRESSION
#define inflateInit(strm)
#define deflateInit(strm, level)
#define Z_DEFAULT_COMPRESSION
const char *ZEXPORT zlibVersion()
const char *ZEXPORT zError(int err)