#include <ruby.h>

#include <zlib.h>

#include <time.h>

#include <ruby/io.h>

#include <ruby/thread.h>

#ifdef HAVE_VALGRIND_MEMCHECK_H

# include <valgrind/memcheck.h>

# ifndef VALGRIND_MAKE_MEM_DEFINED

# define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))

# ifndef VALGRIND_MAKE_MEM_UNDEFINED

# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))

# define VALGRIND_MAKE_MEM_DEFINED(p, n) 0

# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0

#define RUBY_ZLIB_VERSION "3.2.3"

#ifndef RB_PASS_CALLED_KEYWORDS

# define rb_class_new_instance_kw(argc, argv, klass, kw_splat) rb_class_new_instance(argc, argv, klass)

#ifndef GZIP_SUPPORT

#define GZIP_SUPPORT 1

#ifndef DEF_MEM_LEVEL

#if MAX_MEM_LEVEL >= 8

#define DEF_MEM_LEVEL 8

#define DEF_MEM_LEVEL MAX_MEM_LEVEL

#if defined(HAVE_ZLIB_SIZE_T_FUNCS)

typedef uLong (*checksum_func)(uLong, const Bytef*, z_size_t);

# define crc32 crc32_z

# define adler32 adler32_z

typedef uLong (*checksum_func)(uLong, const Bytef*, uInt);

#if SIZEOF_LONG > SIZEOF_INT

static inline uInt

max_uint(long n)

{

if (n > UINT_MAX) n = UINT_MAX;

return (uInt)n;

}

#define MAX_UINT(n) max_uint(n)

#define MAX_UINT(n) (uInt)(n)

#define OPTHASH_GIVEN_P(opts) \

(argc > 0 && !NIL_P((opts) = rb_check_hash_type(argv[argc-1])) && (--argc, 1))

static ID id_dictionaries, id_read, id_buffer;

static NORETURN(void raise_zlib_error(int, const char*));

static VALUE rb_zlib_version(VALUE);

static VALUE do_checksum(int, VALUE*, checksum_func);

static VALUE rb_zlib_adler32(int, VALUE*, VALUE);

static VALUE rb_zlib_crc32(int, VALUE*, VALUE);

static VALUE rb_zlib_crc_table(VALUE);

static voidpf zlib_mem_alloc(voidpf, uInt, uInt);

static void zlib_mem_free(voidpf, voidpf);

static void finalizer_warn(const char*);

struct zstream;

struct zstream_funcs;

struct zstream_run_args;

static void zstream_init(struct zstream*, const struct zstream_funcs*);

static void zstream_expand_buffer(struct zstream*);

static void zstream_expand_buffer_into(struct zstream*, unsigned long);

static int zstream_expand_buffer_non_stream(struct zstream *z);

static void zstream_append_buffer(struct zstream*, const Bytef*, long);

static VALUE zstream_detach_buffer(struct zstream*);

static VALUE zstream_shift_buffer(struct zstream*, long, VALUE);

static void zstream_buffer_ungets(struct zstream*, const Bytef*, unsigned long);

static void zstream_buffer_ungetbyte(struct zstream*, int);

static void zstream_append_input(struct zstream*, const Bytef*, long);

static void zstream_discard_input(struct zstream*, long);

static void zstream_reset_input(struct zstream*);

static void zstream_passthrough_input(struct zstream*);

static VALUE zstream_detach_input(struct zstream*);

static void zstream_reset(struct zstream*);

static VALUE zstream_end(struct zstream*);

static VALUE zstream_ensure_end(VALUE v);

static void zstream_run(struct zstream*, Bytef*, long, int);

static VALUE zstream_sync(struct zstream*, Bytef*, long);

static void zstream_mark(void*);

static void zstream_free(void*);

static VALUE zstream_new(VALUE, const struct zstream_funcs*);

static struct zstream *get_zstream(VALUE);

static void zstream_finalize(struct zstream*);

static VALUE rb_zstream_end(VALUE);

static VALUE rb_zstream_reset(VALUE);

static VALUE rb_zstream_finish(VALUE);

static VALUE rb_zstream_flush_next_in(VALUE);

static VALUE rb_zstream_flush_next_out(VALUE);

static VALUE rb_zstream_avail_out(VALUE);

static VALUE rb_zstream_set_avail_out(VALUE, VALUE);

static VALUE rb_zstream_avail_in(VALUE);

static VALUE rb_zstream_total_in(VALUE);

static VALUE rb_zstream_total_out(VALUE);

static VALUE rb_zstream_data_type(VALUE);

static VALUE rb_zstream_adler(VALUE);

static VALUE rb_zstream_finished_p(VALUE);

static VALUE rb_zstream_closed_p(VALUE);

static VALUE rb_deflate_s_allocate(VALUE);

static VALUE rb_deflate_initialize(int, VALUE*, VALUE);

static VALUE rb_deflate_init_copy(VALUE, VALUE);

static VALUE deflate_run(VALUE);

static VALUE rb_deflate_s_deflate(int, VALUE*, VALUE);

static void do_deflate(struct zstream*, VALUE, int);

static VALUE rb_deflate_deflate(int, VALUE*, VALUE);

static VALUE rb_deflate_addstr(VALUE, VALUE);

static VALUE rb_deflate_flush(int, VALUE*, VALUE);

static VALUE rb_deflate_params(VALUE, VALUE, VALUE);

static VALUE rb_deflate_set_dictionary(VALUE, VALUE);

static VALUE inflate_run(VALUE);

static VALUE rb_inflate_s_allocate(VALUE);

static VALUE rb_inflate_initialize(int, VALUE*, VALUE);

static VALUE rb_inflate_s_inflate(VALUE, VALUE);

static void do_inflate(struct zstream*, VALUE);

static VALUE rb_inflate_inflate(int, VALUE*, VALUE);

static VALUE rb_inflate_addstr(VALUE, VALUE);

static VALUE rb_inflate_sync(VALUE, VALUE);

static VALUE rb_inflate_sync_point_p(VALUE);

static VALUE rb_inflate_set_dictionary(VALUE, VALUE);

#if GZIP_SUPPORT

struct gzfile;

static void gzfile_mark(void*);

static void gzfile_free(void*);

static VALUE gzfile_new(VALUE, const struct zstream_funcs*, void (*) _((struct gzfile*)));

static void gzfile_reset(struct gzfile*);

static void gzfile_close(struct gzfile*, int);

static void gzfile_write_raw(struct gzfile*);

static VALUE gzfile_read_raw_partial(VALUE);

static VALUE gzfile_read_raw_rescue(VALUE,VALUE);

static VALUE gzfile_read_raw(struct gzfile*, VALUE outbuf);

static int gzfile_read_raw_ensure(struct gzfile*, long, VALUE outbuf);

static char *gzfile_read_raw_until_zero(struct gzfile*, long);

static unsigned int gzfile_get16(const unsigned char*);

static unsigned long gzfile_get32(const unsigned char*);

static void gzfile_set32(unsigned long n, unsigned char*);

static void gzfile_make_header(struct gzfile*);

static void gzfile_make_footer(struct gzfile*);

static void gzfile_read_header(struct gzfile*, VALUE outbuf);

static void gzfile_check_footer(struct gzfile*, VALUE outbuf);

static void gzfile_write(struct gzfile*, Bytef*, long);

static long gzfile_read_more(struct gzfile*, VALUE outbuf);

static void gzfile_calc_crc(struct gzfile*, VALUE);

static VALUE gzfile_read(struct gzfile*, long, VALUE);

static VALUE gzfile_read_all(struct gzfile*, VALUE);

static void gzfile_ungets(struct gzfile*, const Bytef*, long);

static void gzfile_ungetbyte(struct gzfile*, int);

static VALUE gzfile_writer_end_run(VALUE);

static void gzfile_writer_end(struct gzfile*);

static VALUE gzfile_reader_end_run(VALUE);

static void gzfile_reader_end(struct gzfile*);

static void gzfile_reader_rewind(struct gzfile*);

static VALUE gzfile_reader_get_unused(struct gzfile*);

static struct gzfile *get_gzfile(VALUE);

static VALUE gzfile_ensure_close(VALUE);

static VALUE rb_gzfile_s_wrap(int, VALUE*, VALUE);

static VALUE gzfile_s_open(int, VALUE*, VALUE, const char*);

NORETURN(static void gzfile_raise(struct gzfile *, VALUE, const char *));

static VALUE gzfile_error_inspect(VALUE);

static VALUE rb_gzfile_to_io(VALUE);

static VALUE rb_gzfile_crc(VALUE);

static VALUE rb_gzfile_mtime(VALUE);

static VALUE rb_gzfile_level(VALUE);

static VALUE rb_gzfile_os_code(VALUE);

static VALUE rb_gzfile_orig_name(VALUE);

static VALUE rb_gzfile_comment(VALUE);

static VALUE rb_gzfile_lineno(VALUE);

static VALUE rb_gzfile_set_lineno(VALUE, VALUE);

static VALUE rb_gzfile_set_mtime(VALUE, VALUE);

static VALUE rb_gzfile_set_orig_name(VALUE, VALUE);

static VALUE rb_gzfile_set_comment(VALUE, VALUE);

static VALUE rb_gzfile_close(VALUE);

static VALUE rb_gzfile_finish(VALUE);

static VALUE rb_gzfile_closed_p(VALUE);

static VALUE rb_gzfile_eof_p(VALUE);

static VALUE rb_gzfile_sync(VALUE);

static VALUE rb_gzfile_set_sync(VALUE, VALUE);

static VALUE rb_gzfile_total_in(VALUE);

static VALUE rb_gzfile_total_out(VALUE);

static VALUE rb_gzfile_path(VALUE);

static VALUE rb_gzwriter_s_allocate(VALUE);

static VALUE rb_gzwriter_s_open(int, VALUE*, VALUE);

static VALUE rb_gzwriter_initialize(int, VALUE*, VALUE);

static VALUE rb_gzwriter_flush(int, VALUE*, VALUE);

static VALUE rb_gzwriter_write(int, VALUE*, VALUE);

static VALUE rb_gzwriter_putc(VALUE, VALUE);

static VALUE rb_gzreader_s_allocate(VALUE);

static VALUE rb_gzreader_s_open(int, VALUE*, VALUE);

static VALUE rb_gzreader_initialize(int, VALUE*, VALUE);

static VALUE rb_gzreader_rewind(VALUE);

static VALUE rb_gzreader_unused(VALUE);

static VALUE rb_gzreader_read(int, VALUE*, VALUE);

static VALUE rb_gzreader_getc(VALUE);

static VALUE rb_gzreader_readchar(VALUE);

static VALUE rb_gzreader_each_byte(VALUE);

static VALUE rb_gzreader_ungetc(VALUE, VALUE);

static VALUE rb_gzreader_ungetbyte(VALUE, VALUE);

static void gzreader_skip_linebreaks(struct gzfile*);

static VALUE gzreader_gets(int, VALUE*, VALUE);

static VALUE rb_gzreader_gets(int, VALUE*, VALUE);

static VALUE rb_gzreader_readline(int, VALUE*, VALUE);

static VALUE rb_gzreader_each(int, VALUE*, VALUE);

static VALUE rb_gzreader_readlines(int, VALUE*, VALUE);

#endif /* GZIP_SUPPORT */

void Init_zlib(void);

static VALUE cZError, cStreamEnd, cNeedDict;

static VALUE cStreamError, cDataError, cMemError, cBufError, cVersionError, cInProgressError;

static void

raise_zlib_error(int err, const char *msg)

{

VALUE exc;

if (!msg) {

msg = zError(err);

}

switch(err) {

case Z_STREAM_END:

exc = rb_exc_new2(cStreamEnd, msg);

break;

case Z_NEED_DICT:

exc = rb_exc_new2(cNeedDict, msg);

break;

case Z_STREAM_ERROR:

exc = rb_exc_new2(cStreamError, msg);

break;

case Z_DATA_ERROR:

exc = rb_exc_new2(cDataError, msg);

break;

case Z_BUF_ERROR:

exc = rb_exc_new2(cBufError, msg);

break;

case Z_VERSION_ERROR:

exc = rb_exc_new2(cVersionError, msg);

break;

case Z_MEM_ERROR:

exc = rb_exc_new2(cMemError, msg);

break;

case Z_ERRNO:

rb_sys_fail(msg);

/* no return */

default:

exc = rb_exc_new_str(cZError,

rb_sprintf("unknown zlib error %d: %s", err, msg));

}

rb_exc_raise(exc);

}

static void

finalizer_warn(const char *msg)

{

#if 0

fprintf(stderr, "zlib(finalizer): %s\n", msg);

}

static VALUE

rb_zlib_version(VALUE klass)

{

return rb_str_new2(zlibVersion());

}

#if SIZEOF_LONG * CHAR_BIT > 32

# define mask32(x) ((x) & 0xffffffff)

# define mask32(x) (x)

#if SIZEOF_LONG > SIZEOF_INT && !defined(HAVE_ZLIB_SIZE_T_FUNCS)

static uLong

checksum_long(uLong (*func)(uLong, const Bytef*, uInt), uLong sum, const Bytef *ptr, long len)

{

if (len > UINT_MAX) {

do {

sum = func(mask32(sum), ptr, UINT_MAX);

ptr += UINT_MAX;

len -= UINT_MAX;

} while (len >= UINT_MAX);

}

if (len > 0) sum = func(mask32(sum), ptr, (uInt)len);

return sum;

}

#define checksum_long(func, sum, ptr, len) (func)(mask32(sum), (ptr), (len))

static VALUE

do_checksum(int argc, VALUE *argv, checksum_func func)

{

VALUE str, vsum;

unsigned long sum;

rb_scan_args(argc, argv, "02", &str, &vsum);

if (!NIL_P(vsum)) {

sum = NUM2ULONG(vsum);

}

else if (NIL_P(str)) {

sum = 0;

}

else {

sum = func(0, Z_NULL, 0);

}

if (NIL_P(str)) {

sum = func(mask32(sum), Z_NULL, 0);

}

else if (rb_obj_is_kind_of(str, rb_cIO)) {

VALUE buf;

VALUE buflen = INT2NUM(8192);

while (!NIL_P(buf = rb_funcall(str, id_read, 1, buflen))) {

StringValue(buf);

sum = checksum_long(func, sum, (Bytef*)RSTRING_PTR(buf), RSTRING_LEN(buf));

}

}

else {

StringValue(str);

sum = checksum_long(func, sum, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));

}

return rb_uint2inum(sum);

}

static VALUE

rb_zlib_adler32(int argc, VALUE *argv, VALUE klass)

{

return do_checksum(argc, argv, adler32);

}

#ifdef HAVE_ADLER32_COMBINE

static VALUE

rb_zlib_adler32_combine(VALUE klass, VALUE adler1, VALUE adler2, VALUE len2)

{

return ULONG2NUM(

adler32_combine(NUM2ULONG(adler1), NUM2ULONG(adler2), NUM2LONG(len2)));

}

#define rb_zlib_adler32_combine rb_f_notimplement

static VALUE

rb_zlib_crc32(int argc, VALUE *argv, VALUE klass)

{

return do_checksum(argc, argv, crc32);

}

#ifdef HAVE_CRC32_COMBINE

static VALUE

rb_zlib_crc32_combine(VALUE klass, VALUE crc1, VALUE crc2, VALUE len2)

{

return ULONG2NUM(

crc32_combine(NUM2ULONG(crc1), NUM2ULONG(crc2), NUM2LONG(len2)));

}

#define rb_zlib_crc32_combine rb_f_notimplement

static VALUE

rb_zlib_crc_table(VALUE obj)

{

#if !defined(HAVE_TYPE_Z_CRC_T)

/* z_crc_t is defined since zlib-1.2.7. */

typedef unsigned long z_crc_t;

const z_crc_t *crctbl;

VALUE dst;

int i;

crctbl = get_crc_table();

dst = rb_ary_new2(256);

for (i = 0; i < 256; i++) {

rb_ary_push(dst, rb_uint2inum(crctbl[i]));

}

return dst;

}

struct zstream {

};

#define ZSTREAM_FLAG_READY (1 << 0)

#define ZSTREAM_FLAG_IN_STREAM (1 << 1)

#define ZSTREAM_FLAG_FINISHED (1 << 2)

#define ZSTREAM_FLAG_CLOSING (1 << 3)

#define ZSTREAM_FLAG_GZFILE (1 << 4) /* disallows yield from expand_buffer for

#define ZSTREAM_REUSE_BUFFER (1 << 5)

#define ZSTREAM_IN_PROGRESS (1 << 6)

#define ZSTREAM_FLAG_UNUSED (1 << 7)

#define ZSTREAM_READY(z) ((z)->flags |= ZSTREAM_FLAG_READY)

#define ZSTREAM_IS_READY(z) ((z)->flags & ZSTREAM_FLAG_READY)

#define ZSTREAM_IS_FINISHED(z) ((z)->flags & ZSTREAM_FLAG_FINISHED)

#define ZSTREAM_IS_CLOSING(z) ((z)->flags & ZSTREAM_FLAG_CLOSING)

#define ZSTREAM_IS_GZFILE(z) ((z)->flags & ZSTREAM_FLAG_GZFILE)

#define ZSTREAM_BUF_FILLED(z) (NIL_P((z)->buf) ? 0 : RSTRING_LEN((z)->buf))

#define ZSTREAM_REUSE_BUFFER_P(z) ((z)->flags & ZSTREAM_REUSE_BUFFER)

#define ZSTREAM_EXPAND_BUFFER_OK 0

#define ZSTREAM_INITIAL_BUFSIZE 1024

#define ZSTREAM_AVAIL_OUT_STEP_MAX 16384

#define ZSTREAM_AVAIL_OUT_STEP_MIN 2048

static const struct zstream_funcs deflate_funcs = {

deflateReset, deflateEnd, deflate,

};

static const struct zstream_funcs inflate_funcs = {

inflateReset, inflateEnd, inflate,

};

struct zstream_run_args {

};

static voidpf

zlib_mem_alloc(voidpf opaque, uInt items, uInt size)

{

voidpf p = xmalloc2(items, size);

/* zlib FAQ: Valgrind (or some similar memory access checker) says that

(void)VALGRIND_MAKE_MEM_DEFINED(p, items * size);

return p;

}

static void

zlib_mem_free(voidpf opaque, voidpf address)

{

xfree(address);

}

static void

zstream_init(struct zstream *z, const struct zstream_funcs *func)

{

z->flags = 0;

z->buf = Qnil;

z->input = Qnil;

z->mutex = rb_mutex_new();

z->stream.zalloc = zlib_mem_alloc;

z->stream.zfree = zlib_mem_free;

z->stream.opaque = Z_NULL;

z->stream.msg = Z_NULL;

z->stream.next_in = Z_NULL;

z->stream.avail_in = 0;

z->stream.next_out = Z_NULL;

z->stream.avail_out = 0;

z->func = func;

}

#define zstream_init_deflate(z) zstream_init((z), &deflate_funcs)

#define zstream_init_inflate(z) zstream_init((z), &inflate_funcs)

static void

zstream_expand_buffer(struct zstream *z)

{

if (NIL_P(z->buf)) {

zstream_expand_buffer_into(z, ZSTREAM_INITIAL_BUFSIZE);

return;

}

if (!ZSTREAM_IS_GZFILE(z) && rb_block_given_p()) {

long buf_filled = ZSTREAM_BUF_FILLED(z);

if (buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {

int state = 0;

if (!ZSTREAM_REUSE_BUFFER_P(z)) {

rb_obj_reveal(z->buf, rb_cString);

}

rb_protect(rb_yield, z->buf, &state);

if (ZSTREAM_REUSE_BUFFER_P(z)) {

rb_str_modify(z->buf);

rb_str_set_len(z->buf, 0);

}

else {

z->buf = Qnil;

}

zstream_expand_buffer_into(z, ZSTREAM_AVAIL_OUT_STEP_MAX);

if (state)

rb_jump_tag(state);

return;

}

else {

zstream_expand_buffer_into(z,

ZSTREAM_AVAIL_OUT_STEP_MAX - buf_filled);

}

}

else {

zstream_expand_buffer_non_stream(z);

}

}

static void

zstream_expand_buffer_into(struct zstream *z, unsigned long size)

{

if (NIL_P(z->buf)) {

/* I uses rb_str_new here not rb_str_buf_new because

z->buf = rb_str_buf_new(size);

z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);

z->stream.avail_out = MAX_UINT(size);

rb_obj_hide(z->buf);

}

else if (z->stream.avail_out != size) {

rb_str_modify_expand(z->buf, size);

z->stream.next_out = (Bytef*)RSTRING_END(z->buf);

z->stream.avail_out = MAX_UINT(size);

}

}

static int

zstream_expand_buffer_protect(struct zstream *z)

{

int state = 0;

rb_protect((VALUE (*)(VALUE))zstream_expand_buffer, (VALUE)z, &state);

return state;

}

static int

zstream_expand_buffer_non_stream(struct zstream *z)

{

long inc, len = ZSTREAM_BUF_FILLED(z);

if (rb_str_capacity(z->buf) - len >= ZSTREAM_AVAIL_OUT_STEP_MAX) {

z->stream.avail_out = ZSTREAM_AVAIL_OUT_STEP_MAX;

}

else {

inc = len / 2;

if (inc < ZSTREAM_AVAIL_OUT_STEP_MIN) {

inc = ZSTREAM_AVAIL_OUT_STEP_MIN;

}

rb_str_modify_expand(z->buf, inc);

z->stream.avail_out = (inc < ZSTREAM_AVAIL_OUT_STEP_MAX) ?

(int)inc : ZSTREAM_AVAIL_OUT_STEP_MAX;

}

z->stream.next_out = (Bytef*)RSTRING_END(z->buf);

return ZSTREAM_EXPAND_BUFFER_OK;

}

static void

zstream_append_buffer(struct zstream *z, const Bytef *src, long len)

{

if (NIL_P(z->buf)) {

z->buf = rb_str_buf_new(len);

rb_str_buf_cat(z->buf, (const char*)src, len);

z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);

z->stream.avail_out = 0;

rb_obj_hide(z->buf);

return;

}

if ((long)rb_str_capacity(z->buf) < ZSTREAM_BUF_FILLED(z) + len) {

rb_str_modify_expand(z->buf, len);

z->stream.avail_out = 0;

}

else {

if (z->stream.avail_out >= (uInt)len) {

z->stream.avail_out -= (uInt)len;

}

else {

z->stream.avail_out = 0;

}

}

rb_str_cat(z->buf, (const char *)src, len);

z->stream.next_out = (Bytef*)RSTRING_END(z->buf);

}

#define zstream_append_buffer2(z,v) \

zstream_append_buffer((z),(Bytef*)RSTRING_PTR(v),RSTRING_LEN(v))

static VALUE

zstream_detach_buffer(struct zstream *z)

{

VALUE dst;

if (!ZSTREAM_IS_FINISHED(z) && !ZSTREAM_IS_GZFILE(z) &&

rb_block_given_p()) {

/* prevent tiny yields mid-stream, save for next

return Qnil;

}

if (NIL_P(z->buf)) {

dst = rb_str_new(0, 0);

}

else {

dst = z->buf;

if (!ZSTREAM_REUSE_BUFFER_P(z)) {

rb_obj_reveal(dst, rb_cString);

}

}

z->buf = Qnil;

z->stream.next_out = 0;

z->stream.avail_out = 0;

if (!ZSTREAM_IS_GZFILE(z) && rb_block_given_p()) {

rb_yield(dst);

dst = Qnil;

}

return dst;

}

static VALUE

zstream_shift_buffer(struct zstream *z, long len, VALUE dst)

{

char *bufptr;

long buflen = ZSTREAM_BUF_FILLED(z);

if (buflen <= len) {

if (NIL_P(dst) || (!ZSTREAM_IS_FINISHED(z) && !ZSTREAM_IS_GZFILE(z) &&

rb_block_given_p())) {

return zstream_detach_buffer(z);

} else {

bufptr = RSTRING_PTR(z->buf);

rb_str_resize(dst, buflen);

memcpy(RSTRING_PTR(dst), bufptr, buflen);

}

buflen = 0;

} else {

bufptr = RSTRING_PTR(z->buf);

if (NIL_P(dst)) {

dst = rb_str_new(bufptr, len);

} else {

rb_str_resize(dst, len);

memcpy(RSTRING_PTR(dst), bufptr, len);

}

buflen -= len;

}

memmove(bufptr, bufptr + len, buflen);

rb_str_set_len(z->buf, buflen);

z->stream.next_out = (Bytef*)RSTRING_END(z->buf);

buflen = (long)rb_str_capacity(z->buf) - ZSTREAM_BUF_FILLED(z);

if (buflen > ZSTREAM_AVAIL_OUT_STEP_MAX) {

buflen = ZSTREAM_AVAIL_OUT_STEP_MAX;

}

z->stream.avail_out = (uInt)buflen;

return dst;

}

static void

zstream_buffer_ungets(struct zstream *z, const Bytef *b, unsigned long len)

{

char *bufptr;

long filled;

zstream_expand_buffer_into(z, len);

RSTRING_GETMEM(z->buf, bufptr, filled);

memmove(bufptr + len, bufptr, filled);

memmove(bufptr, b, len);

rb_str_set_len(z->buf, filled + len);

if (z->stream.avail_out > 0) {

if (len > z->stream.avail_out) len = z->stream.avail_out;

z->stream.next_out+=len;

z->stream.avail_out-=(uInt)len;

}

}

static void

zstream_buffer_ungetbyte(struct zstream *z, int c)

{

Bytef cc = (Bytef)c;

zstream_buffer_ungets(z, &cc, 1);

}

static void

zstream_append_input(struct zstream *z, const Bytef *src, long len)

{

if (len <= 0) return;

if (NIL_P(z->input)) {

z->input = rb_str_buf_new(len);

rb_str_buf_cat(z->input, (const char*)src, len);

rb_obj_hide(z->input);

}

else {

rb_str_buf_cat(z->input, (const char*)src, len);

}

}

#define zstream_append_input2(z,v)\

RB_GC_GUARD(v),\

zstream_append_input((z), (Bytef*)RSTRING_PTR(v), RSTRING_LEN(v))

static void

zstream_discard_input(struct zstream *z, long len)

{

if (NIL_P(z->input)) {

}

else if (RBASIC_CLASS(z->input) == 0) {

/* hidden, we created z->input and have complete control */

char *ptr;

long oldlen, newlen;

RSTRING_GETMEM(z->input, ptr, oldlen);

newlen = oldlen - len;

if (newlen > 0) {

memmove(ptr, ptr + len, newlen);

}

if (newlen < 0) {

newlen = 0;

}

rb_str_resize(z->input, newlen);

if (newlen == 0) {

z->input = Qnil;

}

else {

rb_str_set_len(z->input, newlen);

}

}

else { /* do not mangle user-provided data */

if (RSTRING_LEN(z->input) <= len) {

z->input = Qnil;

}

else {

z->input = rb_str_subseq(z->input, len,

RSTRING_LEN(z->input) - len);

}

}

}

static void

zstream_reset_input(struct zstream *z)

{

if (!NIL_P(z->input) && RBASIC_CLASS(z->input) == 0) {

rb_str_resize(z->input, 0);

}

else {

z->input = Qnil;

}

}

static void

zstream_passthrough_input(struct zstream *z)

{

if (!NIL_P(z->input)) {

zstream_append_buffer2(z, z->input);

z->input = Qnil;

}

}

static VALUE

zstream_detach_input(struct zstream *z)

{

VALUE dst;

if (NIL_P(z->input)) {

dst = rb_str_new(0, 0);

}

else {

dst = z->input;

rb_obj_reveal(dst, rb_cString);

}

z->input = Qnil;

return dst;

}

static void

zstream_reset(struct zstream *z)

{

int err;

err = z->func->reset(&z->stream);

if (err != Z_OK) {

raise_zlib_error(err, z->stream.msg);

}

z->flags = ZSTREAM_FLAG_READY;

z->buf = Qnil;

z->stream.next_out = 0;

z->stream.avail_out = 0;

zstream_reset_input(z);

}

static VALUE

zstream_end(struct zstream *z)

{

int err;

if (!ZSTREAM_IS_READY(z)) {

rb_warning("attempt to close uninitialized zstream; ignored.");

return Qnil;

}

if (z->flags & ZSTREAM_FLAG_IN_STREAM) {