File Coverage

Zlib.xs

Criterion	Covered	Total	%
statement	332	612	54.2
branch	200	500	40.0
condition			n/a
subroutine			n/a
pod			n/a
total	532	1112	47.8

/* Filename: Zlib.xs
  * Author  : Paul Marquess, <[e-mail]>
  * Created : 22nd January 1996
  * Version : 2.000
  *
  *   Copyright (c) 1995-2013 Paul Marquess. All rights reserved.
  *   This program is free software; you can redistribute it and/or
 *   modify it under the same terms as Perl itself.
 *
 */

/* Parts of this code are based on the files gzio.c and gzappend.c from
  * the standard zlib source distribution. Below are the copyright statements
  * from each.
  */

/* gzio.c -- IO on .gz files
 * Copyright (C) 1995 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* gzappend -- command to append to a gzip file

  Copyright (C) 2003 Mark Adler, all rights reserved
  version 1.1, 4 Nov 2003
*/


#define PERL_NO_GET_CONTEXT
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#if USE_ZLIB_NG
#  include "zlib-ng.h"
#else
#  include "zlib.h"
#endif


/* zlib prior to 1.06 doesn't know about z_off_t */
#ifndef z_off_t
#  define z_off_t   long
#endif

#if ! USE_ZLIB_NG && (! defined(ZLIB_VERNUM) || ZLIB_VERNUM < 0x1200)
#  define NEED_DUMMY_BYTE_AT_END
#endif

#if USE_ZLIB_NG || (defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1210)
#  define MAGIC_APPEND
#  define AT_LEAST_ZLIB_1_2_1
#endif

#if USE_ZLIB_NG || (defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1221)
#  define AT_LEAST_ZLIB_1_2_2_1
#endif

#if USE_ZLIB_NG || (defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1222)
#  define AT_LEAST_ZLIB_1_2_2_2
#endif

#if USE_ZLIB_NG || (defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1223)
#  define AT_LEAST_ZLIB_1_2_2_3
#endif

#if USE_ZLIB_NG || (defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1230)
#  define AT_LEAST_ZLIB_1_2_3
#endif

#if USE_ZLIB_NG || (defined(ZLIB_VERNUM) && ZLIB_VERNUM >= 0x1252)
/*
    Use Z_SOLO to build source means need own malloc/free
 */
#  define AT_LEAST_ZLIB_1_2_5_2
#endif


/* zlib vs zlib-ng */

#if USE_ZLIB_NG

/* zlibng native */

#  define HAVE_ZLIB_NG_NATIVE       TRUE
#  define HAVE_ZLIB_NG_COMPAT       FALSE

#  ifndef ZLIBNG_VER_STATUS
#    define ZLIBNG_VER_STATUS 0
#  endif

#  ifndef ZLIBNG_VER_MODIFIED
#    define ZLIBNG_VER_MODIFIED 0
#  endif

#  define CRZ_adlerInitial          zng_adler32(0L, Z_NULL, 0)
#  define CRZ_crcInitial            zng_crc32(0L, Z_NULL, 0)

#  define CRZ_ZSTREAM               zng_stream



#  define CRZ_adler32               zng_adler32
#  define CRZ_adler32_combine       zng_adler32_combine
#  define CRZ_crc32                 zng_crc32
#  define CRZ_crc32_combine         zng_crc32_combine
#  define CRZ_deflate               zng_deflate
#  define CRZ_deflateEnd            zng_deflateEnd
#  define CRZ_deflateInit           zng_deflateInit
#  define CRZ_deflateInit2          zng_deflateInit2
#  define CRZ_deflateParams         zng_deflateParams
#  define CRZ_deflatePrime          zng_deflatePrime
#  define CRZ_deflateReset          zng_deflateReset
#  define CRZ_deflateSetDictionary  zng_deflateSetDictionary
#  define CRZ_deflateTune           zng_deflateTune
#  define CRZ_inflate               zng_inflate
#  define CRZ_inflateEnd            zng_inflateEnd
#  define CRZ_inflateInit2          zng_inflateInit2
#  define CRZ_inflateReset          zng_inflateReset
#  define CRZ_inflateSetDictionary  zng_inflateSetDictionary
#  define CRZ_inflateSync           zng_inflateSync
#  define CRZ_zlibCompileFlags      zng_zlibCompileFlags


/* zlib  symbols & functions */

// #  define CRZ_ZLIB_VERSION          ZLIBNG_VERSION
// #  define ZLIB_VERSION              ZLIBNG_VERSION
#  define CRZ_ZLIB_VERSION          ""
#  define ZLIB_VERSION              ""

// #  define CRZ_zlibVersion           zlibng_version
// #  define CRZ_zlib_version          zlibng_version

   const char *CRZ_zlibVersion(void)  { return ""; }
   const char *CRZ_zlib_version(void) { return ""; }


#else /* zlib specific */


#  define HAVE_ZLIB_NG_NATIVE       FALSE

/* Is this real zlib or zlib-ng in compat mode */
#  ifdef ZLIBNG_VERSION
          /* zlib-ng in compat mode */
#    define HAVE_ZLIB_NG_COMPAT     TRUE

#    ifndef ZLIBNG_VER_STATUS
#      define ZLIBNG_VER_STATUS 0
#    endif

#    ifndef ZLIBNG_VER_MODIFIED
#      define ZLIBNG_VER_MODIFIED 0
#    endif

      const char *zlibng_version(void)  { return ZLIBNG_VERSION ; }


#  else
          /* zlib native mode */

#    define HAVE_ZLIB_NG_COMPAT     FALSE

          /* zlib doesn't have the ZLIBNG synbols, so create them */
#    define ZLIBNG_VERSION          ""
#    define ZLIBNG_VERNUM           0
#    define ZLIBNG_VER_MAJOR        0
#    define ZLIBNG_VER_MINOR        0
#    define ZLIBNG_VER_REVISION     0
#    define ZLIBNG_VER_STATUS       0
#    define ZLIBNG_VER_MODIFIED     0
#    define ZLIBNG_VERNUM           0

      const char *zlibng_version(void) { return ""; }

#  endif



#  define CRZ_adlerInitial          adler32(0L, Z_NULL, 0)
#  define CRZ_crcInitial            crc32(0L, Z_NULL, 0)

#  define CRZ_ZSTREAM               z_stream

#  define CRZ_adler32               adler32
#  define CRZ_adler32_combine       adler32_combine
#  define CRZ_crc32                 crc32
#  define CRZ_crc32_combine         crc32_combine
#  define CRZ_deflate               deflate
#  define CRZ_deflateEnd            deflateEnd
#  define CRZ_deflateInit           deflateInit
#  define CRZ_deflateInit2          deflateInit2
#  define CRZ_deflateParams         deflateParams
#  define CRZ_deflatePrime          deflatePrime
#  define CRZ_deflateReset          deflateReset
#  define CRZ_deflateSetDictionary  deflateSetDictionary
#  define CRZ_deflateTune           deflateTune
#  define CRZ_inflate               inflate
#  define CRZ_inflateEnd            inflateEnd
#  define CRZ_inflateInit2          inflateInit2
#  define CRZ_inflateReset          inflateReset
#  define CRZ_inflateSetDictionary  inflateSetDictionary
#  define CRZ_inflateSync           inflateSync
#  define CRZ_zlibCompileFlags      zlibCompileFlags
#  define CRZ_zlibVersion           zlibVersion
#  define CRZ_zlib_version          zlibVersion

#endif


#ifdef USE_PPPORT_H
#  define NEED_sv_2pvbyte
#  define NEED_sv_2pv_nolen
#  define NEED_sv_pvn_force_flags
#  include "ppport.h"

/* Proposed fix for https://github.com/Dual-Life/Devel-PPPort/issues/231 */

#  if PERL_VERSION < 18
#    ifdef sv_2pv
#   undef sv_2pv
#  endif

#  if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
#    define sv_2pv(sv, lp) ({ SV *_sv_2pv = (sv); SvPOKp(_sv_2pv) ? ((*(lp) = SvCUR(_sv_2pv)), SvPVX(_sv_2pv)) : Perl_sv_2pv(aTHX_ _sv_2pv, (lp)); })
#  else
#    define sv_2pv(sv, lp) (SvPOKp(sv) ? ((*(lp) = SvCUR(sv)), SvPVX(sv)) : Perl_sv_2pv(aTHX_ (sv), (lp)))
#  endif

#endif

#endif

#if PERL_REVISION == 5 && PERL_VERSION == 9
        /* For Andreas */
#   define sv_pvbyte_force(sv,lp) sv_pvbyten_force(sv,lp)
#endif

#if PERL_REVISION == 5 && (PERL_VERSION < 8 || (PERL_VERSION == 8 && PERL_SUBVERSION < 4 ))

#    ifdef SvPVbyte_force
#        undef SvPVbyte_force
#    endif

#    define SvPVbyte_force(sv,lp) SvPV_force(sv,lp)

#endif

#ifndef SvPVbyte_nolen
#    define SvPVbyte_nolen SvPV_nolen
#endif



#if 0
#  ifndef SvPVbyte_nolen
#    define SvPVbyte_nolen SvPV_nolen
#  endif

#  ifndef SvPVbyte_force
#    define SvPVbyte_force(sv,lp) SvPV_force(sv,lp)
#  endif
#endif

#if PERL_REVISION == 5 && (PERL_VERSION >= 8 || (PERL_VERSION == 8 && PERL_SUBVERSION < 4 ))
#    define UTF8_AVAILABLE
#endif

typedef int                     DualType ;
typedef int                     int_undef ;

typedef struct di_stream {
        int      flags ;
#define FLAG_APPEND             1
#define FLAG_CRC32              2
#define FLAG_ADLER32            4
#define FLAG_CONSUME_INPUT      8
#define FLAG_LIMIT_OUTPUT       16
        uLong    crc32 ;
        uLong    adler32 ;
        CRZ_ZSTREAM stream;
        uLong    bufsize;
        SV *     dictionary ;
        uLong    dict_adler ;
        int      last_error ;
        bool     zip_mode ;
/* #define SETP_BYTE */
#ifdef SETP_BYTE
    /* SETP_BYTE only works with zlib up to 1.2.8 */
    bool     deflateParams_out_valid ;
    Bytef    deflateParams_out_byte;
#else
#define deflateParams_BUFFER_SIZE       0x40000
    uLong    deflateParams_out_length;
    Bytef*   deflateParams_out_buffer;
#endif
    int      Level;
    int      Method;
    int      WindowBits;
    int      MemLevel;
    int      Strategy;
    uLong    bytesInflated ;
    uLong    compressedBytes ;
    uLong    uncompressedBytes ;
#ifdef MAGIC_APPEND

#define WINDOW_SIZE 32768U

    bool     matchedEndBlock;
    Bytef*   window ;
    int      window_lastbit,  window_left,  window_full;
    unsigned window_have;
    off_t    window_lastoff, window_end;
    off_t    window_endOffset;

    uLong    lastBlockOffset ;
    unsigned char window_lastByte ;


#endif
} di_stream;

typedef di_stream * deflateStream ;
typedef di_stream * Compress__Raw__Zlib__deflateStream ;
typedef di_stream * inflateStream ;
typedef di_stream * Compress__Raw__Zlib__inflateStream ;
typedef di_stream * Compress__Raw__Zlib__inflateScanStream ;

#define ZMALLOC(to, typ) (to = (typ *)safecalloc(sizeof(typ), 1))

/* Figure out the Operating System */
#ifdef MSDOS
#  define OS_CODE  0x00
#endif

#if defined(AMIGA) || defined(AMIGAOS) || defined(__amigaos4__)
#  define OS_CODE  0x01
#endif

#if defined(VAXC) || defined(VMS)
#  define OS_CODE  0x02
#endif

#if 0 /* VM/CMS */
#  define OS_CODE  0x04
#endif

#if defined(ATARI) || defined(atarist)
#  define OS_CODE  0x05
#endif

#ifdef OS2
#  define OS_CODE  0x06
#endif

#if defined(MACOS) || defined(TARGET_OS_MAC)
#  define OS_CODE  0x07
#endif

#if 0 /* Z-System */
#  define OS_CODE  0x08
#endif

#if 0 /* CP/M */
#  define OS_CODE  0x09
#endif

#ifdef TOPS20
#  define OS_CODE  0x0a
#endif

#ifdef WIN32 /* Window 95 & Windows NT */
#  define OS_CODE  0x0b
#endif

#if 0 /* QDOS */
#  define OS_CODE  0x0c
#endif

#if 0 /* Acorn RISCOS */
#  define OS_CODE  0x0d
#endif

#if 0 /* ???  */
#  define OS_CODE  0x0e
#endif

#ifdef __50SERIES /* Prime/PRIMOS */
#  define OS_CODE  0x0F
#endif

/* Default to UNIX */
#ifndef OS_CODE
#  define OS_CODE  0x03  /* assume Unix */
#endif

#ifndef GZIP_OS_CODE
#  define GZIP_OS_CODE OS_CODE
#endif


/* static const char * const my_z_errmsg[] = { */
static const char my_z_errmsg[][32] = {
    "need dictionary",     /* Z_NEED_DICT     2 */
    "stream end",          /* Z_STREAM_END    1 */
    "",                    /* Z_OK            0 */
    "file error",          /* Z_ERRNO        (-1) */
    "stream error",        /* Z_STREAM_ERROR (-2) */
    "data error",          /* Z_DATA_ERROR   (-3) */
    "insufficient memory", /* Z_MEM_ERROR    (-4) */
    "buffer error",        /* Z_BUF_ERROR    (-5) */
    "incompatible version",/* Z_VERSION_ERROR(-6) */
    ""};

#define setDUALstatus(var, err)                                         \
                sv_setnv(var, (double)err) ;                            \
                sv_setpv(var, ((err) ? GetErrorString(err) : "")) ;     \
                SvNOK_on(var);


#if defined(__SYMBIAN32__)
# define NO_WRITEABLE_DATA
#endif

/* Set TRACE_DEFAULT to a non-zero value to enable tracing */
#define TRACE_DEFAULT 0

#if defined(NO_WRITEABLE_DATA) || TRACE_DEFAULT == 0
#  define trace TRACE_DEFAULT
#else
  static int trace = TRACE_DEFAULT ;
#endif

/* Dodge PerlIO hiding of these functions. */
#undef printf

static char *
#ifdef CAN_PROTOTYPE
GetErrorString(int error_no)
#else
GetErrorString(error_no)
int error_no ;
#endif
{
    dTHX;
    char * errstr ;

    if (error_no == Z_ERRNO) {
        errstr = Strerror(errno) ;
    }
    else
        /* errstr = gzerror(fil, &error_no) ; */
        errstr = (char*) my_z_errmsg[2 - error_no];

    return errstr ;
}


#ifdef MAGIC_APPEND

/*
      The following two functions are taken almost directly from
      examples/gzappend.c. Only cosmetic changes have been made to conform to
   the coding style of the rest of the code in this file.
*/


/* return the greatest common divisor of a and b using Euclid's algorithm,
   modified to be fast when one argument much greater than the other, and
   coded to avoid unnecessary swapping */
static unsigned
#ifdef CAN_PROTOTYPE
gcd(unsigned a, unsigned b)
#else
gcd(a, b)
        unsigned a;
        unsigned b;
#endif
{
        unsigned c;

        while (a && b)
                if (a > b) {
                        c = b;
                        while (a - c >= c)
                                c <<= 1;
                        a -= c;
                }
                else {
                        c = a;
                        while (b - c >= c)
                                c <<= 1;
                        b -= c;
                }
        return a + b;
}

/* rotate list[0..len-1] left by rot positions, in place */
static void
#ifdef CAN_PROTOTYPE
rotate(unsigned char *list, unsigned len, unsigned rot)
#else
rotate(list, len, rot)
        unsigned char *list;
        unsigned len ;
        unsigned rot;
#endif
{
        unsigned char tmp;
        unsigned cycles;
        unsigned char *start, *last, *to, *from;

        /* normalize rot and handle degenerate cases */
        if (len < 2) return;
        if (rot >= len) rot %= len;
        if (rot == 0) return;

        /* pointer to last entry in list */
    last = list + (len - 1);

    /* do simple left shift by one */
    if (rot == 1) {
        tmp = *list;
        memmove(list, list + 1, len - 1);
        *last = tmp;
        return;
    }

    /* do simple right shift by one */
    if (rot == len - 1) {
        tmp = *last;
        memmove(list + 1, list, len - 1);
        *list = tmp;
        return;
    }

    /* otherwise do rotate as a set of cycles in place */
    cycles = gcd(len, rot);             /* number of cycles */
    do {
        start = from = list + cycles;   /* start index is arbitrary */
        tmp = *from;                    /* save entry to be overwritten */
        for (;;) {
            to = from;                  /* next step in cycle */
            from += rot;                /* go right rot positions */
            if (from > last) from -= len;   /* (pointer better not wrap) */
            if (from == start) break;   /* all but one shifted */
            *to = *from;                /* shift left */
        }
        *to = tmp;                      /* complete the circle */
    } while (--cycles);
}

#endif /* MAGIC_APPEND */

static void
#ifdef CAN_PROTOTYPE
DispHex(const void * ptr, int length)
#else
DispHex(ptr, length)
    const void * ptr;
    int length;
#endif
{
    char * p = (char*)ptr;
    int i;
    for (i = 0; i < length; ++i) {
        printf(" %02x", 0xFF & *(p+i));
    }
}


static void
#ifdef CAN_PROTOTYPE
DispStream(di_stream * s, const char * message)
#else
DispStream(s, message)
        di_stream * s;
        const char * message;
#endif
{

#if 0
        if (! trace)
                return ;
#endif

#define EnDis(f) (s->flags & f ? "Enabled" : "Disabled")

        printf("DispStream %p", s) ;
        if (message)
                printf("- %s \n", message) ;
    printf("\n") ;

    if (!s)  {
                printf("    stream pointer is NULL\n");
        }
        else     {
                printf("    stream           %p\n", &(s->stream));
        printf("           zalloc    %p\n", s->stream.zalloc);
                printf("           zfree     %p\n", s->stream.zfree);
                printf("           opaque    %p\n", s->stream.opaque);
        printf("           state     %p\n", s->stream.state);
                if (s->stream.msg)
                        printf("           msg       %s\n", s->stream.msg);
        else
            printf("           msg       \n");
        printf("           next_in   %p", s->stream.next_in);
                if (s->stream.next_in){
                        printf(" =>");
                        DispHex(s->stream.next_in, 4);
        }
        printf("\n");

        printf("           next_out  %p", s->stream.next_out);
                if (s->stream.next_out){
                        printf(" =>");
                        DispHex(s->stream.next_out, 4);
        }
        printf("\n");

        printf("           avail_in  %lu\n",  (unsigned long)s->stream.avail_in);
                printf("           avail_out %lu\n",  (unsigned long)s->stream.avail_out);
                printf("           total_in  %ld\n",  s->stream.total_in);
        printf("           total_out %ld\n",  s->stream.total_out);
#if ! USE_ZLIB_NG
                printf("           adler     %ld\n",  s->stream.adler    );
#else
                printf("           adler     %u\n",  s->stream.adler    );
#endif
        printf("    bufsize          %ld\n",  s->bufsize);
                printf("    dictionary       %p\n",   s->dictionary);
                printf("    dict_adler       0x%ld\n",s->dict_adler);
        printf("    zip_mode         %d\n",   s->zip_mode);
                printf("    crc32            0x%x\n", (unsigned)s->crc32);
                printf("    adler32          0x%x\n", (unsigned)s->adler32);
        printf("    flags            0x%x\n", s->flags);
                printf("           APPEND    %s\n",   EnDis(FLAG_APPEND));
                printf("           CRC32     %s\n",   EnDis(FLAG_CRC32));
                printf("           ADLER32   %s\n",   EnDis(FLAG_ADLER32));
                printf("           CONSUME   %s\n",   EnDis(FLAG_CONSUME_INPUT));
                printf("           LIMIT     %s\n",   EnDis(FLAG_LIMIT_OUTPUT));


#ifdef MAGIC_APPEND
                printf("    window           %p\n", s->window);
#endif
                printf("\n");

        }
}

#ifdef AT_LEAST_ZLIB_1_2_5_2
voidpf my_zcalloc (voidpf opaque, unsigned items, unsigned size)
{
        PERL_UNUSED_VAR(opaque);
        /* TODO - put back to calloc */
        /* return safecalloc(items, size); */
    return (voidpf)safemalloc(items* size);
}


void my_zcfree (voidpf opaque, voidpf ptr)
{
    PERL_UNUSED_VAR(opaque);
    safefree(ptr);
    return;
}

#endif

static di_stream *
#ifdef CAN_PROTOTYPE
InitStream(void)
#else
InitStream()
#endif
{
    di_stream *s ;

    ZMALLOC(s, di_stream) ;

#ifdef AT_LEAST_ZLIB_1_2_5_2
        s->stream.zalloc = my_zcalloc;
        s->stream.zfree = my_zcfree;
#endif

        return s ;
}

static void
#ifdef CAN_PROTOTYPE
PostInitStream(di_stream * s, int flags, int bufsize, int windowBits)
#else
PostInitStream(s, flags, bufsize, windowBits)
    di_stream *s ;
    int flags ;
    int bufsize ;
    int windowBits ;
#endif
{
    s->bufsize = bufsize ;
        s->compressedBytes =
        s->uncompressedBytes =
    s->last_error = 0 ;
        s->flags    = flags ;
        s->zip_mode = (windowBits < 0) ;
    if (flags & FLAG_CRC32)
        s->crc32 = CRZ_crcInitial ;
        if (flags & FLAG_ADLER32)
                s->adler32 = CRZ_adlerInitial ;
}


static SV*
#ifdef CAN_PROTOTYPE
deRef(SV * sv, const char * string)
#else
deRef(sv, string)
SV * sv ;
char * string;
#endif
{
        dTHX;
        SvGETMAGIC(sv);

        if (SvROK(sv)) {
                sv = SvRV(sv) ;
                SvGETMAGIC(sv);
                switch(SvTYPE(sv)) {
                        case SVt_PVAV:
                        case SVt_PVHV:
                        case SVt_PVCV:
                                croak("%s: buffer parameter is not a SCALAR reference", string);
                        default:
                                break;
                }
                if (SvROK(sv))
                        croak("%s: buffer parameter is a reference to a reference", string) ;
        }

        if (!SvOK(sv))
                sv = sv_2mortal(newSVpv("", 0));

        return sv ;
}

static SV*
#ifdef CAN_PROTOTYPE
deRef_l(SV * sv, const char * string)
#else
deRef_l(sv, string)
SV * sv ;
char * string ;
#endif
{
        dTHX;
        bool wipe = 0 ;
        STRLEN na;

        SvGETMAGIC(sv);
        wipe = ! SvOK(sv) ;

        if (SvROK(sv)) {
                sv = SvRV(sv) ;
                SvGETMAGIC(sv);
                wipe = ! SvOK(sv) ;

                switch(SvTYPE(sv)) {
                        case SVt_PVAV:
                        case SVt_PVHV:
                        case SVt_PVCV:
                                croak("%s: buffer parameter is not a SCALAR reference", string);
                        default:
                                break;
                }
                if (SvROK(sv))
                        croak("%s: buffer parameter is a reference to a reference", string) ;
        }

        if (SvREADONLY(sv) && PL_curcop != &PL_compiling)
                croak("%s: buffer parameter is read-only", string);

        SvUPGRADE(sv, SVt_PV);

        if (wipe)
                sv_setpv(sv, "") ;
        else
                (void)SvPVbyte_force(sv, na) ;

        return sv ;
}

#if 0
int
flushToBuffer(di_stream* s, int flush)
{
        dTHX;
        int ret ;
        CRZ_ZSTREAM * strm = &s->stream;

        Bytef* output = s->deflateParams_out_buffer ;

        strm->next_in = NULL;
        strm->avail_in = 0;

        uLong total_output = 0;
        uLong have = 0;

        do
        {
                if (output)
                        output = (unsigned char *)saferealloc(output, total_output + s->bufsize);
                else
                        output = (unsigned char *)safemalloc(s->bufsize);

                strm->next_out  = output + total_output;
                strm->avail_out = s->bufsize;

                ret = deflate(strm, flush);    /* no bad return value */
                //assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
                if(ret == Z_STREAM_ERROR)
                {
                        safefree(output);
                        return ret;
                }
                have = s->bufsize - strm->avail_out;
                total_output += have;

                //fprintf(stderr, "FLUSH %s %d, return %d\n", flush_flags[flush], have, ret);

        } while (strm->avail_out == 0);

        s->deflateParams_out_buffer = output;
        s->deflateParams_out_length = total_output;

        return Z_OK;
}
#endif

#ifndef SETP_BYTE
int
flushParams(di_stream* s)
{
        dTHX;
        int ret ;
        CRZ_ZSTREAM * strm = &s->stream;

        Bytef* output = s->deflateParams_out_buffer ;
        uLong total_output = s->deflateParams_out_length;
        uLong have = 0;

        strm->next_in = NULL;
        strm->avail_in = 0;


        do
        {
                if (output)
                        output = (unsigned char *)saferealloc(output, total_output + s->bufsize);
                else
                        output = (unsigned char *)safemalloc(s->bufsize);

                strm->next_out  = output + total_output;
                strm->avail_out = s->bufsize;

                ret = CRZ_deflateParams(&(s->stream), s->Level, s->Strategy);
                /* fprintf(stderr, "deflateParams %d %s %lu\n", ret,
                        GetErrorString(ret),  s->bufsize - strm->avail_out); */

                if (ret == Z_STREAM_ERROR)
                        break;

                have = s->bufsize - strm->avail_out;
                total_output += have;


        } while (ret == Z_BUF_ERROR) ;

        if(ret == Z_STREAM_ERROR)
                safefree(output);
        else
        {
                s->deflateParams_out_buffer = output;
                s->deflateParams_out_length = total_output;
        }

        return ret;
}
#endif /* ! SETP_BYTE */

#include "constants.h"

MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib        PREFIX = Zip_

REQUIRE:	1.924
PROTOTYPES:	DISABLE

INCLUDE: constants.xs

BOOT:
#if ! USE_ZLIB_NG
        /* Check this version of zlib is == 1 */
        if (CRZ_zlibVersion()[0] != '1')
                croak("Compress::Raw::Zlib needs zlib version 1.x\n") ;
#endif

        {
                /* Create the $os_code scalar */
                SV * os_code_sv = perl_get_sv("Compress::Raw::Zlib::gzip_os_code", GV_ADDMULTI) ;
                sv_setiv(os_code_sv, GZIP_OS_CODE) ;
        }

        {
                /* BUILD_ZLIB  */
                SV * os_code_sv = perl_get_sv("Compress::Raw::Zlib::BUILD_ZLIB", GV_ADDMULTI) ;
                sv_setiv(os_code_sv, Perl_crz_BUILD_ZLIB) ;
        }

#define Zip_zlib_version()	(const char*)CRZ_zlib_version()
const char*
Zip_zlib_version()

const char*
zlibng_version()

#define Zip_is_zlib_native()	(! (HAVE_ZLIB_NG_NATIVE || HAVE_ZLIB_NG_COMPAT))
bool
Zip_is_zlib_native()

#define Zip_is_zlibng_native()	(bool)HAVE_ZLIB_NG_NATIVE
bool
Zip_is_zlibng_native()

#define Zip_is_zlibng_compat()	(bool)HAVE_ZLIB_NG_COMPAT
bool
Zip_is_zlibng_compat()

#define Zip_is_zlibng()	(bool)(HAVE_ZLIB_NG_NATIVE || HAVE_ZLIB_NG_COMPAT)
bool
Zip_is_zlibng()

unsigned
ZLIB_VERNUM()
        CODE:
#ifdef ZLIB_VERNUM
                RETVAL = ZLIB_VERNUM ;
#elif USE_ZLIB_NG
                RETVAL = 0 ;
#else
                /* 1.1.4 => 0x1140 */
                RETVAL  = (CRZ_ZLIB_VERSION[0] - '0') << 12 ;
                RETVAL += (CRZ_ZLIB_VERSION[2] - '0') <<  8 ;
                RETVAL += (CRZ_ZLIB_VERSION[4] - '0') <<  4 ;
                if (strlen(CRZ_ZLIB_VERSION) > 5)
                        RETVAL += (CRZ_ZLIB_VERSION[6] - '0')  ;
#endif
        OUTPUT:
                RETVAL


#ifndef AT_LEAST_ZLIB_1_2_1
#  define Zip_zlibCompileFlags  0
#else
#  define Zip_zlibCompileFlags  CRZ_zlibCompileFlags
#endif
uLong
Zip_zlibCompileFlags()

const char*
ZLIBNG_VER_STATUS()
        CODE:
#ifdef ZLIBNG_VER_STATUS
                RETVAL = STRINGIFY(ZLIBNG_VER_STATUS);
#else
                RETVAL = "0";
#endif
        OUTPUT:
                RETVAL

MODULE = Compress::Raw::Zlib	PACKAGE = Compress::Raw::Zlib	PREFIX = Zip_

#define Zip_adler32(buf, adler) CRZ_adler32(adler, buf, (uInt)len)

uLong
Zip_adler32(buf, adler=CRZ_adlerInitial)
                uLong    adler = NO_INIT
                STRLEN   len = NO_INIT
                Bytef *  buf = NO_INIT
		SV *	 sv = ST(0) ;
		INIT:
    	    	/* If the buffer is a reference, dereference it */
		sv = deRef(sv, "adler32") ;
#ifdef UTF8_AVAILABLE
        if (DO_UTF8(sv) && !sv_utf8_downgrade(sv, 1))
                  croak("Wide character in Compress::Raw::Zlib::adler32");
#endif
		buf = (Byte*)SvPVbyte(sv, len) ;

		if (items < 2)
	  	  adler = CRZ_adlerInitial;
		else if (SvOK(ST(1)))
	  	  adler = SvUV(ST(1)) ;
		else
	  	  adler = CRZ_adlerInitial;
        OUTPUT:
                RETVAL

#define Zip_crc32(buf, crc, offset) CRZ_crc32(crc, buf+offset, (uInt)len-offset)

uLong
Zip_crc32(buf, crc=CRZ_crcInitial, offset=0)
                uLong    crc = NO_INIT
                STRLEN   len = NO_INIT
                Bytef *  buf = NO_INIT
                STRLEN   offset
		SV *	 sv = ST(0) ;
		INIT:
    	    	/* If the buffer is a reference, dereference it */
		sv = deRef(sv, "crc32") ;
#ifdef UTF8_AVAILABLE
        if (DO_UTF8(sv) && !sv_utf8_downgrade(sv, 1))
                  croak("Wide character in Compress::Raw::Zlib::crc32");
#endif
		buf = (Byte*)SvPVbyte(sv, len) ;

		if (offset > len)
	  	  croak("Offset out of range in Compress::Raw::Zlib::crc32");

		if (items < 2)
	  	  crc = CRZ_crcInitial;
		else if (SvOK(ST(1)))
	  	  crc = SvUV(ST(1)) ;
		else
	  	  crc = CRZ_crcInitial;

uLong
crc32_combine(crc1, crc2, len2)
                uLong    crc1
                uLong    crc2
                z_off_t   len2
		CODE:
#ifndef AT_LEAST_ZLIB_1_2_2_1
                crc1 = crc1; crc2 = crc2 ; len2 = len2; /* Silence -Wall */
                croak("crc32_combine needs zlib 1.2.3 or better");
#else
                RETVAL = CRZ_crc32_combine(crc1, crc2, len2);
#endif
        OUTPUT:
                RETVAL


uLong
adler32_combine(adler1, adler2, len2)
                uLong    adler1
                uLong    adler2
                z_off_t   len2
		CODE:
#ifndef AT_LEAST_ZLIB_1_2_2_1
                adler1 = adler1; adler2 = adler2 ; len2 = len2; /* Silence -Wall */
                croak("adler32_combine needs zlib 1.2.3 or better");
#else
                RETVAL = CRZ_adler32_combine(adler1, adler2, len2);
#endif
        OUTPUT:
                RETVAL


MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib

void
_deflateInit(flags,level, method, windowBits, memLevel, strategy, bufsize, dictionary)
        int flags
        int	level
        int method
        int windowBits
        int memLevel
        int strategy
        uLong bufsize
        SV* dictionary
    PPCODE:
        int err ;
        deflateStream s ;

        if (trace)
                warn("in _deflateInit(level=%d, method=%d, windowBits=%d, memLevel=%d, strategy=%d, bufsize=%ld dictionary=%p)\n",
		level, method, windowBits, memLevel, strategy, bufsize, dictionary) ;
        if ((s = InitStream() )) {

                s->Level      = level;
                s->Method     = method;
                s->WindowBits = windowBits;
                s->MemLevel   = memLevel;
                s->Strategy   = strategy;

                err = CRZ_deflateInit2(&(s->stream), level,
			   			   method, windowBits, memLevel, strategy);

                if (trace) {
                        warn(" _deflateInit2 returned %d (state %p)\n", err, s);
                        DispStream(s, "INIT");
                }

		/* Check if a dictionary has been specified */
		SvGETMAGIC(dictionary);
		if (err == Z_OK && SvPOK(dictionary) && SvCUR(dictionary)) {
#ifdef UTF8_AVAILABLE
                        if (DO_UTF8(dictionary) && !sv_utf8_downgrade(dictionary, 1))
                                croak("Wide character in Compress::Raw::Zlib::Deflate::new dicrionary parameter");
#endif
	    	    err = CRZ_deflateSetDictionary(&(s->stream), (const Bytef*) SvPVX(dictionary), SvCUR(dictionary)) ;
                if (trace)
                        warn("deflateSetDictionary returned %d\n", err);
	    	    s->dict_adler = s->stream.adler ;
		}

                if (err != Z_OK) {
                        Safefree(s) ;
                        s = NULL ;
		}
		else
	    	    PostInitStream(s, flags, bufsize, windowBits) ;

        }
        else
                err = Z_MEM_ERROR ;

        {
                SV* obj = sv_setref_pv(sv_newmortal(),
                        "Compress::Raw::Zlib::deflateStream", (void*)s);
                XPUSHs(obj);
        }
        if (GIMME_V == G_ARRAY) {
                SV * sv = sv_2mortal(newSViv(err)) ;
		setDUALstatus(sv, err);
                XPUSHs(sv) ;
        }

void
_inflateInit(flags, windowBits, bufsize, dictionary)
        int flags
        int windowBits
        uLong bufsize
        SV * dictionary
    ALIAS:
        _inflateScanInit = 1
    PPCODE:

        int err = Z_OK ;
        inflateStream s ;
#ifndef MAGIC_APPEND
        if (ix == 1)
                croak("inflateScanInit needs zlib 1.2.1 or better");
#endif
        if (trace)
                warn("in _inflateInit(windowBits=%d, bufsize=%lu, dictionary=%lu\n",
                                windowBits, bufsize, (unsigned long)SvCUR(dictionary)) ;
        if ((s = InitStream() )) {

                s->WindowBits = windowBits;

                err = CRZ_inflateInit2(&(s->stream), windowBits);
                if (err != Z_OK) {
                        Safefree(s) ;
                        s = NULL ;
		}
		else if (sv_len(dictionary)) {
#ifdef AT_LEAST_ZLIB_1_2_2_1
                /* Zlib 1.2.2.1 or better allows a dictionary with raw inflate */
                if (s->WindowBits < 0) {
                        STRLEN dlen;
                        const Bytef* b = (const Bytef*)SvPVbyte(dictionary, dlen);
                        err = CRZ_inflateSetDictionary(&(s->stream),
                                b, dlen);
                        if (err != Z_OK) {
                                Safefree(s) ;
                                s = NULL ;
                        }
                }
                else
#endif
                        /* Dictionary specified - take a copy for use in inflate */
	    	    s->dictionary = newSVsv(dictionary) ;
		}
		if (s) {
	    	    PostInitStream(s, flags, bufsize, windowBits) ;
#ifdef MAGIC_APPEND
                        if (ix == 1)
                        {
                                s->window = (unsigned char *)safemalloc(WINDOW_SIZE);
                        }
#endif
                }
        }
        else
		err = Z_MEM_ERROR ;

        {
                SV* obj = sv_setref_pv(sv_newmortal(),
                                      ix == 1
                                      ? "Compress::Raw::Zlib::inflateScanStream"
                                      :  "Compress::Raw::Zlib::inflateStream",
                                      (void*)s);
                XPUSHs(obj);
        }
        if (GIMME_V == G_ARRAY) {
                SV * sv = sv_2mortal(newSViv(err)) ;
		setDUALstatus(sv, err);
                XPUSHs(sv) ;
        }



MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib::deflateStream

void
DispStream(s, message=NULL)
        Compress::Raw::Zlib::deflateStream   s
        const char *  message

DualType
deflateReset(s)
        Compress::Raw::Zlib::deflateStream   s
    CODE:
            RETVAL = CRZ_deflateReset(&(s->stream)) ;
            if (RETVAL == Z_OK) {
	  	  PostInitStream(s, s->flags, s->bufsize, s->WindowBits) ;
            }
        OUTPUT:
            RETVAL

DualType
deflate (s, buf, output)
        Compress::Raw::Zlib::deflateStream	s
        SV *	buf
        SV * 	output
        uInt	cur_length = NO_INIT
        uInt	increment = NO_INIT
        uInt	prefix    = NO_INIT
        int		RETVAL = 0;
        uLong     bufinc = NO_INIT
        STRLEN    origlen = NO_INIT
    CODE:
        bufinc = s->bufsize;

        /*
        if (trace) {
                printf("\nDEFLATE Before deRef of input buffer\n");
                printf("\nPerl_sv_dump\n");
                Perl_sv_dump(buf);
                printf("\n");
        }
        */

        /* If the input buffer is a reference, dereference it */
        buf = deRef(buf, "deflate") ;

        /* initialise the input buffer */
#ifdef UTF8_AVAILABLE
        if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
                  croak("Wide character in Compress::Raw::Zlib::Deflate::deflate input parameter");
#endif
        s->stream.next_in = (Bytef*)SvPV_nomg(buf, origlen) ;
        s->stream.avail_in = origlen;

        if (trace) {
                printf("\nDEFLATE Starts\n");
                DispStream(s, "START");
                /*
                printf("\nPerl_sv_dump\n");
                Perl_sv_dump(buf);
                printf("\n");
                */
        }

        if (s->flags & FLAG_CRC32)
                s->crc32 = CRZ_crc32(s->crc32, s->stream.next_in, s->stream.avail_in) ;

        if (s->flags & FLAG_ADLER32)
                s->adler32 = CRZ_adler32(s->adler32, s->stream.next_in, s->stream.avail_in) ;

        /* and retrieve the output buffer */
        output = deRef_l(output, "deflate") ;
#ifdef UTF8_AVAILABLE
        if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
                  croak("Wide character in Compress::Raw::Zlib::Deflate::deflate output parameter");
#endif

          if((s->flags & FLAG_APPEND) == FLAG_APPEND) {
                  SvOOK_off(output);
          } else {
                  SvCUR_set(output, 0);
          }
        prefix = cur_length =  SvCUR(output) ;
        s->stream.next_out = (Bytef*) SvPVX(output) + cur_length;
        increment =  SvLEN(output) -  cur_length;
        s->stream.avail_out =  increment;
#ifdef SETP_BYTE
        /* Check for saved output from deflateParams */
        if (s->deflateParams_out_valid) {
		*(s->stream.next_out) = s->deflateParams_out_byte;
		++ s->stream.next_out;
		-- s->stream.avail_out ;
		s->deflateParams_out_valid = FALSE;
        }
#else
        /* Check for saved output from deflateParams */
        if (s->deflateParams_out_length) {
                uLong plen = s->deflateParams_out_length ;
                /* printf("Copy %lu bytes saved data\n", plen); */
                if (s->stream.avail_out < plen) {
                        /* printf("GROW from %d to %lu\n", s->stream.avail_out,
                                                SvLEN(output) + plen - s->stream.avail_out);  */
                          s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + plen - s->stream.avail_out) ;
                          s->stream.next_out += cur_length;
                }

                Copy(s->deflateParams_out_buffer, s->stream.next_out, plen, Bytef) ;
                cur_length += plen;
                SvCUR_set(output, cur_length);
                s->stream.next_out += plen ;
                s->stream.avail_out = SvLEN(output) - cur_length ;
                increment = s->stream.avail_out;

                s->deflateParams_out_length = 0;
                Safefree(s->deflateParams_out_buffer);
                s->deflateParams_out_buffer = NULL;
        }
#endif
        RETVAL = Z_OK ;
        while (s->stream.avail_in != 0) {

                if (s->stream.avail_out == 0) {
	    	    /* out of space in the output buffer so make it bigger */
                        s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + bufinc) ;
                        cur_length += increment ;
                        s->stream.next_out += cur_length ;
                        increment = bufinc ;
                        s->stream.avail_out = increment;
                        bufinc *= 2 ;
                }

                if (trace) {
                    printf("DEFLATE Avail In %d, Out %d\n", s->stream.avail_in, s->stream.avail_out);
                    DispStream(s, "BEFORE");
                    /* Perl_sv_dump(output); */
                }

                RETVAL = CRZ_deflate(&(s->stream), Z_NO_FLUSH);
                /*
                if (RETVAL != Z_STREAM_ERROR) {
                        int done = increment -  s->stream.avail_out ;
                        printf("std DEFLATEr returned %d '%s'  avail in %d, out %d wrote %d\n", RETVAL,
                        GetErrorString(RETVAL), s->stream.avail_in, s->stream.avail_out, done);
                }
                */

                if (trace) {
                        printf("DEFLATE returned %d %s, avail in %d, out %d\n", RETVAL,
           GetErrorString(RETVAL), s->stream.avail_in, s->stream.avail_out);
                        DispStream(s, "AFTER");
                }

                if (RETVAL != Z_OK)
                        break;
        }

        s->compressedBytes += cur_length + increment - prefix - s->stream.avail_out ;
        s->uncompressedBytes  += origlen - s->stream.avail_in  ;

        s->last_error = RETVAL ;
        if (RETVAL == Z_OK) {
                SvPOK_only(output);
                SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
                SvSETMAGIC(output);
        }
        OUTPUT:
		RETVAL


void
DESTROY(s)
        Compress::Raw::Zlib::deflateStream	s
    CODE:
        if (trace)
                printf("Compress::Raw::Zlib::deflateStream::DESTROY %p\n", s);
        CRZ_deflateEnd(&s->stream) ;
        if (s->dictionary)
	SvREFCNT_dec(s->dictionary) ;
#ifndef SETP_BYTE
        if (s->deflateParams_out_buffer)
                Safefree(s->deflateParams_out_buffer);
#endif
    Safefree(s) ;


DualType
flush(s, output, f=Z_FINISH)
        Compress::Raw::Zlib::deflateStream	s
        SV * output
        int  f
        uInt	cur_length = NO_INIT
        uInt	increment = NO_INIT
        uInt	prefix    = NO_INIT
        uLong     bufinc = NO_INIT
        uLong     availableout = NO_INIT
    CODE:
        bufinc = s->bufsize;



        /* retrieve the output buffer */
        output = deRef_l(output, "flush") ;
#ifdef UTF8_AVAILABLE
    if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
         croak("Wide character in Compress::Raw::Zlib::Deflate::flush input parameter");
#endif
     if((s->flags & FLAG_APPEND) == FLAG_APPEND) {
                  SvOOK_off(output);
          } else {
                  SvCUR_set(output, 0);
          }
        prefix = cur_length =  SvCUR(output) ;
        s->stream.next_out = (Bytef*) SvPVX(output) + cur_length;
        increment =  SvLEN(output) -  cur_length;
    s->stream.avail_out =  increment;
#ifdef SETP_BYTE
        /* Check for saved output from deflateParams */
        if (s->deflateParams_out_valid) {
		*(s->stream.next_out) = s->deflateParams_out_byte;
		++ s->stream.next_out;
		-- s->stream.avail_out ;
		s->deflateParams_out_valid = FALSE;
        }
#else
        /* Check for saved output from deflateParams */
        if (s->deflateParams_out_length) {
        uLong plen = s->deflateParams_out_length ;
                /* printf("Copy %lu bytes saved data\n", plen); */
                if (s->stream.avail_out < plen) {
                        /* printf("GROW from %d to %lu\n", s->stream.avail_out,
                        SvLEN(output) + plen - s->stream.avail_out); */
                        s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + plen - s->stream.avail_out) ;
                        s->stream.next_out += cur_length;
                }

                Copy(s->deflateParams_out_buffer, s->stream.next_out, plen, Bytef) ;
                cur_length += plen;
                SvCUR_set(output, cur_length);
                s->stream.next_out += plen ;
                s->stream.avail_out = SvLEN(output) - cur_length ;
        increment = s->stream.avail_out;

                s->deflateParams_out_length = 0;
                Safefree(s->deflateParams_out_buffer);
        s->deflateParams_out_buffer = NULL;
        }
#endif

        for (;;) {
                if (s->stream.avail_out == 0) {
                        /* consumed all the available output, so extend it */
                        s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + bufinc) ;
            cur_length += increment ;
            s->stream.next_out += cur_length ;
                        increment = bufinc ;
                        s->stream.avail_out = increment;
                        bufinc *= 2 ;
                }

                availableout = s->stream.avail_out ;

        if (trace) {
          printf("flush (%d) DEFLATE Avail In %d, Out %d\n", f, s->stream.avail_in, s->stream.avail_out);
                    DispStream(s, "BEFORE");
                    /* Perl_sv_dump(output); */
                }

                RETVAL = CRZ_deflate(&(s->stream), f);
        /*
                if (RETVAL != Z_STREAM_ERROR) {
                        int done = availableout -  s->stream.avail_out ;
                        printf("flush DEFLATEr returned %d '%s'  avail in %d, out %d wrote %d\n", RETVAL,
                        GetErrorString(RETVAL), s->stream.avail_in,
s->stream.avail_out, done);
                }
                */

        if (trace) {
            printf("flush DEFLATE returned %d '%s', avail in %d, out %d\n", RETVAL,
            GetErrorString(RETVAL), s->stream.avail_in, s->stream.avail_out);
                        DispStream(s, "AFTER");
                }

                /* Ignore the second of two consecutive flushes: */
                if (availableout == s->stream.avail_out && RETVAL == Z_BUF_ERROR)
            RETVAL = Z_OK;

        /* deflate has finished flushing only when it hasn't used up
                  * all the available space in the output buffer:
                  */
        if (s->stream.avail_out != 0 || RETVAL != Z_OK )
                        break;
        }

        RETVAL =  (RETVAL == Z_STREAM_END ? Z_OK : RETVAL) ;
        s->last_error = RETVAL ;

        s->compressedBytes    += cur_length + increment - prefix - s->stream.avail_out ;

        if (RETVAL == Z_OK) {
                SvPOK_only(output);
                SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
        SvSETMAGIC(output);
    }
    OUTPUT:
	RETVAL


DualType
_deflateParams(s, flags, level, strategy, bufsize)
  	Compress::Raw::Zlib::deflateStream	s
		int 	flags
		int	level
		int	strategy
    	uLong	bufsize
	bool changed = FALSE;
    CODE:
        /* printf("_deflateParams(Flags %d Level %d Strategy %d Bufsize %d)\n", flags, level, strategy, bufsize);
                printf("Before -- Level %d, Strategy %d, Bufsize %d\n", s->Level, s->Strategy, s->bufsize); */
        if (flags & 1 && level != s->Level) {
                        s->Level = level ;
                        changed = TRUE;
                }
                if (flags & 2 && strategy != s->Strategy) {
            s->Strategy = strategy ;
                        changed = TRUE;
                }
                if (flags & 4)
                        s->bufsize = bufsize;
                if (changed) {
#ifdef SETP_BYTE
                        s->stream.avail_in = 0;
            s->stream.next_out = &(s->deflateParams_out_byte) ;
                        s->stream.avail_out = 1;
            RETVAL = deflateParams(&(s->stream), s->Level, s->Strategy);
            s->deflateParams_out_valid =
                        (RETVAL == Z_OK && s->stream.avail_out == 0) ;
#else
                        /* printf("Level %d Strategy %d, Prev Len %d\n",
                                s->Level, s->Strategy, s->deflateParams_out_length); */
                        RETVAL = flushParams(s);
#endif
                }
                else
                        RETVAL = Z_OK;
        OUTPUT:
                RETVAL


int
get_Level(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
		RETVAL = s->Level ;
    OUTPUT:
	RETVAL

int
get_Strategy(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
		RETVAL = s->Strategy ;
        OUTPUT:
		RETVAL


uLong
get_Bufsize(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
		RETVAL = s->bufsize ;
        OUTPUT:
		RETVAL


int
status(s)
        Compress::Raw::Zlib::deflateStream   s
        CODE:
		RETVAL = s->last_error ;
        OUTPUT:
		RETVAL

uLong
crc32(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
	RETVAL = s->crc32 ;
        OUTPUT:
		RETVAL

uLong
dict_adler(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
		RETVAL = s->dict_adler ;
        OUTPUT:
		RETVAL

uLong
adler32(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
		RETVAL = s->adler32 ;
    OUTPUT:
	RETVAL

uLong
compressedBytes(s)
        Compress::Raw::Zlib::deflateStream	s
        CODE:
                RETVAL = s->compressedBytes;
    OUTPUT:
		RETVAL

uLong
uncompressedBytes(s)
        Compress::Raw::Zlib::deflateStream	s
        CODE:
                RETVAL = s->uncompressedBytes;
    OUTPUT:
		RETVAL

uLong
total_in(s)
        Compress::Raw::Zlib::deflateStream   s
        CODE:
                RETVAL = s->stream.total_in ;
        OUTPUT:
		RETVAL

uLong
total_out(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
        RETVAL = s->stream.total_out ;
        OUTPUT:
		RETVAL

char*
msg(s)
                Compress::Raw::Zlib::deflateStream   s
        CODE:
		RETVAL = (char*)s->stream.msg;
        OUTPUT:
		RETVAL

int
deflateTune(s, good_length, max_lazy, nice_length, max_chain)
                        Compress::Raw::Zlib::deflateStream   s
                        int good_length
                        int max_lazy
                        int nice_length
                        int max_chain
        CODE:
#ifndef AT_LEAST_ZLIB_1_2_2_3
                good_length = good_length; max_lazy = max_lazy ; /* Silence -Wall */
                nice_length = nice_length; max_chain = max_chain; /* Silence -Wall */
                croak("deflateTune needs zlib 1.2.2.3 or better");
#else
		RETVAL = CRZ_deflateTune(&(s->stream), good_length, max_lazy, nice_length, max_chain);
#endif
        OUTPUT:
		RETVAL


MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib::inflateStream

void
DispStream(s, message=NULL)
        Compress::Raw::Zlib::inflateStream   s
        const char *  message

DualType
inflateReset(s)
        Compress::Raw::Zlib::inflateStream   s
    CODE:
            RETVAL = CRZ_inflateReset(&(s->stream)) ;
            if (RETVAL == Z_OK) {
	  	  PostInitStream(s, s->flags, s->bufsize, s->WindowBits) ;
            }
        OUTPUT:
            RETVAL

DualType
inflate (s, buf, output, eof=FALSE)
        Compress::Raw::Zlib::inflateStream	s
        SV *	buf
        SV * 	output
        bool 	eof
        uInt	cur_length = 0;
        uInt	prefix_length = 0;
        int	    increment = 0;
        uLong   bufinc = NO_INIT
        STRLEN  na = NO_INIT ;
    PREINIT:
#ifdef UTF8_AVAILABLE
        bool	out_utf8  = FALSE;
#endif
        STRLEN	origlen;
    CODE:
        bufinc = s->bufsize;
        /* If the buffer is a reference, dereference it */
        buf = deRef(buf, "inflate") ;

        if (s->flags & FLAG_CONSUME_INPUT) {
                if (SvREADONLY(buf))
                        croak("Compress::Raw::Zlib::Inflate::inflate input parameter cannot be read-only when ConsumeInput is specified");
                SvPV_force(buf, na);
        }
#ifdef UTF8_AVAILABLE
        if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
                  croak("Wide character in Compress::Raw::Zlib::Inflate::inflate input parameter");
#endif

        /* initialise the input buffer */
        s->stream.next_in = (Bytef*)SvPV_nomg(buf, origlen) ;
        s->stream.avail_in = origlen ;

        /* and retrieve the output buffer */
        output = deRef_l(output, "inflate") ;
#ifdef UTF8_AVAILABLE
        if (DO_UTF8(output))
                  out_utf8 = TRUE ;
        if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
                  croak("Wide character in Compress::Raw::Zlib::Inflate::inflate output parameter");
#endif
          if((s->flags & FLAG_APPEND) == FLAG_APPEND) {
                  SvOOK_off(output);
          } else {
                  SvCUR_set(output, 0);
          }

        /* Assume no output buffer - the code below will update if there is any available */
        s->stream.avail_out = 0;


        if (SvLEN(output)) {
                prefix_length = cur_length =  SvCUR(output) ;

                if (s->flags & FLAG_LIMIT_OUTPUT && SvLEN(output) - cur_length - 1 < bufinc)
                {
                        Sv_Grow(output, bufinc + cur_length + 1) ;
                }

                /* Only setup the stream output pointers if there is spare
           capacity in the outout SV
        */
                if (SvLEN(output) > cur_length + 1)
                {
                        s->stream.next_out = (Bytef*) SvPV_nomg_nolen(output) + cur_length;
                        increment = SvLEN(output) -  cur_length - 1;
                        s->stream.avail_out = increment;
                }
        }


        s->bytesInflated = 0;

        RETVAL = Z_OK;

        while (RETVAL == Z_OK) {
                if (s->stream.avail_out == 0) {
	    	    /* out of space in the output buffer so make it bigger */
                        s->stream.next_out = (Bytef*) Sv_Grow(output, SvLEN(output) + bufinc +1) ;
                        cur_length += increment ;
                        s->stream.next_out += cur_length ;
                        increment = bufinc ;
                        s->stream.avail_out = increment;
                        bufinc *= 2 ;
                }

                /* printf("INFLATE Availl In %d, Out %d\n", s->stream.avail_in,
  s->stream.avail_out);
DispStream(s, "BEFORE");
Perl_sv_dump(output); */
                RETVAL = CRZ_inflate(&(s->stream), Z_SYNC_FLUSH);
        /* printf("INFLATE returned %d %s, avail in %d, out %d\n", RETVAL,
  GetErrorString(RETVAL), s->stream.avail_in, s->stream.avail_out); */


        if (RETVAL == Z_NEED_DICT && s->dictionary) {
                        STRLEN dlen;
                        const Bytef* b = (const Bytef*)SvPV(s->dictionary, dlen) ;
                        s->dict_adler = s->stream.adler ;
                        RETVAL = CRZ_inflateSetDictionary(&(s->stream),
                                b, dlen);
                        if (RETVAL == Z_OK)
                                continue;
                }

                if (s->flags & FLAG_LIMIT_OUTPUT &&
                (RETVAL == Z_OK || RETVAL == Z_BUF_ERROR )) {
            if (s->stream.avail_out == 0)
                                RETVAL = Z_BUF_ERROR;
                        break;
                }
                if (s->flags & FLAG_LIMIT_OUTPUT &&
                                (RETVAL == Z_OK || RETVAL == Z_BUF_ERROR ))
                        break;

                if (RETVAL == Z_STREAM_ERROR || RETVAL == Z_MEM_ERROR ||
                        RETVAL == Z_DATA_ERROR   || RETVAL == Z_STREAM_END )
                        break ;

                if (RETVAL == Z_BUF_ERROR) {
                        if (s->stream.avail_out == 0)
                continue ;
            if (s->stream.avail_in == 0) {
                                RETVAL = Z_OK ;
                                break ;
                        }
                }
        }
#ifdef NEED_DUMMY_BYTE_AT_END
        if (eof && RETVAL == Z_OK && (s->flags & FLAG_LIMIT_OUTPUT) == 0) {
                Bytef* nextIn =  (Bytef*)s->stream.next_in;
        uInt availIn =  s->stream.avail_in;
                s->stream.next_in = (Bytef*) " ";
                s->stream.avail_in = 1;
        if (s->stream.avail_out == 0) {
	    	    /* out of space in the output buffer so make it bigger */
                        s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc) ;
                        cur_length += increment ;
                        s->stream.next_out += cur_length ;
            increment = bufinc ;
            s->stream.avail_out = increment;
                        bufinc *= 2 ;
                }
                RETVAL = CRZ_inflate(&(s->stream), Z_SYNC_FLUSH);
                s->stream.next_in = nextIn ;
        s->stream.avail_in  = availIn ;
        }
#else
        PERL_UNUSED_VAR(eof);
#endif

        s->last_error = RETVAL ;
        if (RETVAL == Z_OK || RETVAL == Z_STREAM_END || RETVAL == Z_BUF_ERROR || RETVAL == Z_DATA_ERROR) {
	   	   unsigned in ;

                s->bytesInflated = cur_length + increment - s->stream.avail_out - prefix_length;
                s->uncompressedBytes += s->bytesInflated ;
                s->compressedBytes   += origlen - s->stream.avail_in  ;

                SvPOK_only(output);
                SvCUR_set(output, prefix_length + s->bytesInflated) ;
		*SvEND(output) = '\0';
#ifdef UTF8_AVAILABLE
                if (out_utf8)
                        sv_utf8_upgrade(output);
#endif
                SvSETMAGIC(output);

                if (s->flags & FLAG_CRC32 )
            s->crc32 = CRZ_crc32(s->crc32,
								(const Bytef*)SvPVX(output)+prefix_length,
            			            			SvCUR(output)-prefix_length) ;

        if (s->flags & FLAG_ADLER32)
                        s->adler32 = CRZ_adler32(s->adler32,
				(const Bytef*)SvPVX(output)+prefix_length,
            			SvCUR(output)-prefix_length) ;

	/* fix the input buffer */
	if (s->flags & FLAG_CONSUME_INPUT || s->flags & FLAG_LIMIT_OUTPUT) {
	    	    in = s->stream.avail_in ;
	    SvCUR_set(buf, in) ;
	    if (in)
	        Move(s->stream.next_in, SvPVX(buf), in, char) ;
                        *SvEND(buf) = '\0';
                        SvSETMAGIC(buf);
		}

        }
        OUTPUT:
		RETVAL

uLong
inflateCount(s)
        Compress::Raw::Zlib::inflateStream	s
        CODE:
                RETVAL = s->bytesInflated;
    OUTPUT:
		RETVAL

uLong
compressedBytes(s)
        Compress::Raw::Zlib::inflateStream	s
        CODE:
                RETVAL = s->compressedBytes;
  OUTPUT:
	RETVAL

uLong
uncompressedBytes(s)
        Compress::Raw::Zlib::inflateStream	s
        CODE:
                RETVAL = s->uncompressedBytes;
    OUTPUT:
		RETVAL


DualType
inflateSync (s, buf)
        Compress::Raw::Zlib::inflateStream	s
        SV *	buf
    CODE:

        /* If the buffer is a reference, dereference it */
        buf = deRef(buf, "inflateSync") ;
#ifdef UTF8_AVAILABLE
    if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
         croak("Wide character in Compress::Raw::Zlib::Inflate::inflateSync");
#endif

    /* initialise the input buffer */
    s->stream.next_in = (Bytef*)SvPV_force_nomg_nolen(buf) ;
        s->stream.avail_in = SvCUR(buf) ;

        /* inflateSync doesn't create any output */
        s->stream.next_out = (Bytef*) NULL;
    s->stream.avail_out = 0;

        RETVAL = CRZ_inflateSync(&(s->stream));
        s->last_error = RETVAL ;

    /* fix the input buffer */
    {
	unsigned in = s->stream.avail_in ;
 	 	SvCUR_set(buf, in) ;
 	 	if (in)
     	         	    Move(s->stream.next_in, SvPVX(buf), in, char) ;
                *SvEND(buf) = '\0';
                SvSETMAGIC(buf);
        }
        OUTPUT:
		RETVAL

void
DESTROY(s)
        Compress::Raw::Zlib::inflateStream	s
    CODE:
        CRZ_inflateEnd(&s->stream) ;
    if (s->dictionary)
		SvREFCNT_dec(s->dictionary) ;
#ifndef SETP_BYTE
        if (s->deflateParams_out_buffer)
        Safefree(s->deflateParams_out_buffer);
#endif
#ifdef MAGIC_APPEND
        if (s->window)
                Safefree(s->window);
#endif
    Safefree(s) ;


uLong
status(s)
                Compress::Raw::Zlib::inflateStream   s
        CODE:
		RETVAL = s->last_error ;
        OUTPUT:
		RETVAL

uLong
crc32(s)
        Compress::Raw::Zlib::inflateStream   s
        CODE:
		RETVAL = s->crc32 ;
        OUTPUT:
		RETVAL

uLong
dict_adler(s)
                Compress::Raw::Zlib::inflateStream   s
        CODE:
	RETVAL = s->dict_adler ;
        OUTPUT:
		RETVAL

uLong
total_in(s)
                Compress::Raw::Zlib::inflateStream   s
        CODE:
                RETVAL = s->stream.total_in ;
        OUTPUT:
		RETVAL

uLong
adler32(s)
                Compress::Raw::Zlib::inflateStream   s
        CODE:
		RETVAL = s->adler32 ;
    OUTPUT:
	RETVAL

uLong
total_out(s)
                Compress::Raw::Zlib::inflateStream   s
        CODE:
                RETVAL = s->stream.total_out ;
        OUTPUT:
		RETVAL

char*
msg(s)
		Compress::Raw::Zlib::inflateStream   s
        CODE:
		RETVAL = (char*)s->stream.msg;
    OUTPUT:
	RETVAL


uLong
get_Bufsize(s)
                Compress::Raw::Zlib::inflateStream   s
        CODE:
		RETVAL = s->bufsize ;
        OUTPUT:
		RETVAL

bool
set_Append(s, mode)
                Compress::Raw::Zlib::inflateStream   s
		bool	mode
        CODE:
                RETVAL = ((s->flags & FLAG_APPEND) == FLAG_APPEND);
	if (mode)
	    s->flags |= FLAG_APPEND ;
		else
	    	    s->flags &= ~FLAG_APPEND ;
        OUTPUT:
                RETVAL

MODULE = Compress::Raw::Zlib PACKAGE = Compress::Raw::Zlib::inflateScanStream

void
DESTROY(s)
        Compress::Raw::Zlib::inflateScanStream	s
    CODE:
        CRZ_inflateEnd(&s->stream) ;
    if (s->dictionary)
		SvREFCNT_dec(s->dictionary) ;
#ifndef SETP_BYTE
        if (s->deflateParams_out_buffer)
        Safefree(s->deflateParams_out_buffer);
#endif
#ifdef MAGIC_APPEND
        if (s->window)
                Safefree(s->window);
#endif
    Safefree(s) ;

void
DispStream(s, message=NULL)
        Compress::Raw::Zlib::inflateScanStream   s
        const char *  message

DualType
inflateReset(s)
    Compress::Raw::Zlib::inflateScanStream   s
    CODE:
            RETVAL = CRZ_inflateReset(&(s->stream)) ;
            if (RETVAL == Z_OK) {
	  	  PostInitStream(s, s->flags, s->bufsize, s->WindowBits) ;
            }
        OUTPUT:
            RETVAL

DualType
scan(s, buf, out=NULL, eof=FALSE)
        Compress::Raw::Zlib::inflateScanStream	s
        SV *	buf
        SV *	out
        bool	eof
        bool	eof_mode = FALSE;
    int    start_len = NO_INIT
  CODE:
    PERL_UNUSED_VAR(out);
    PERL_UNUSED_VAR(eof);
    /* If the input buffer is a reference, dereference it */
#ifndef MAGIC_APPEND
        buf = buf;
        croak("scan needs zlib 1.2.1 or better");
#else
    buf = deRef(buf, "inflateScan") ;
#ifdef UTF8_AVAILABLE
    if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
        croak("Wide character in Compress::Raw::Zlib::InflateScan::scan input parameter");
#endif
    /* initialise the input buffer */
    s->stream.next_in = (Bytef*)SvPV_force_nomg_nolen(buf) ;
        s->stream.avail_in = SvCUR(buf) ;
        start_len = s->stream.avail_in ;
    s->bytesInflated = 0 ;
        do
        {
                if (s->stream.avail_in == 0) {
                        RETVAL = Z_OK ;
                        break ;
                }

                /* set up output to next available section of sliding window */
                s->stream.avail_out = WINDOW_SIZE - s->window_have;
                s->stream.next_out = s->window + s->window_have;

                /* DispStream(s, "before inflate\n"); */

                /* inflate and check for errors */
                RETVAL = CRZ_inflate(&(s->stream), Z_BLOCK);

                if (start_len > 1 && ! eof_mode)
                        s->window_lastByte = *(s->stream.next_in - 1 ) ;

                if (RETVAL == Z_STREAM_ERROR || RETVAL == Z_MEM_ERROR ||
                        RETVAL == Z_DATA_ERROR )
                        break ;

                if (s->flags & FLAG_CRC32 )
            s->crc32 = CRZ_crc32(s->crc32, s->window + s->window_have,
                                                          WINDOW_SIZE - s->window_have - s->stream.avail_out);

                if (s->flags & FLAG_ADLER32)
                        s->adler32 = CRZ_adler32(s->adler32, s->window + s->window_have,
                                 WINDOW_SIZE - s->window_have - s->stream.avail_out);

        s->uncompressedBytes =
                s->bytesInflated += WINDOW_SIZE - s->window_have - s->stream.avail_out;

        if (s->stream.avail_out)
                        s->window_have = WINDOW_SIZE - s->stream.avail_out;
                else {
                        s->window_have = 0;
                        s->window_full = 1;
        }

        /* process end of block */
        if (s->stream.data_type & 128) {
                        if (s->stream.data_type & 64) {
                                s->window_left = s->stream.data_type & 0x1f;
                        }
                        else {
                                s->window_lastbit = s->stream.data_type & 0x1f;
                s->lastBlockOffset = s->stream.total_in;
                        }
                }

        } while (RETVAL != Z_STREAM_END);

        s->last_error = RETVAL ;
    s->window_lastoff = s->stream.total_in ;
        s->compressedBytes += SvCUR(buf) - s->stream.avail_in  ;

        if (RETVAL == Z_STREAM_END)
        {
                s->matchedEndBlock = 1 ;

                /* save the location of the end of the compressed data */
                s->window_end = SvCUR(buf) - s->stream.avail_in - 1 ;
                s->window_endOffset = s->stream.total_in ;
                if (s->window_left)
                {
                        -- s->window_endOffset ;
                }

                /* if window wrapped, build dictionary from window by rotating */
                if (s->window_full) {
                        rotate(s->window, WINDOW_SIZE, s->window_have);
                        s->window_have = WINDOW_SIZE;
                }

                /* if (s->flags & FLAG_CONSUME_INPUT) { */
        if (1) {
            unsigned in = s->stream.avail_in ;
                        SvCUR_set(buf, in) ;
                        if (in)
                                Move(s->stream.next_in, SvPVX(buf), in, char) ;
                        *SvEND(buf) = '\0';
                        SvSETMAGIC(buf);
                }
        }
#endif
    OUTPUT:
		RETVAL


uLong
getEndOffset(s)
        Compress::Raw::Zlib::inflateScanStream	s
        CODE:
#ifndef MAGIC_APPEND
                croak("getEndOffset needs zlib 1.2.1 or better");
#else
                RETVAL = s->window_endOffset;
#endif
  OUTPUT:
	RETVAL

uLong
inflateCount(s)
        Compress::Raw::Zlib::inflateScanStream	s
        CODE:
#ifndef MAGIC_APPEND
                croak("inflateCount needs zlib 1.2.1 or better");
#else
                RETVAL = s->bytesInflated;
#endif
    OUTPUT:
		RETVAL

uLong
compressedBytes(s)
    Compress::Raw::Zlib::inflateScanStream	s
        CODE:
                RETVAL = s->compressedBytes;
    OUTPUT:
		RETVAL

uLong
uncompressedBytes(s)
        Compress::Raw::Zlib::inflateScanStream	s
        CODE:
        RETVAL = s->uncompressedBytes;
    OUTPUT:
		RETVAL


uLong
getLastBlockOffset(s)
        Compress::Raw::Zlib::inflateScanStream	s
        CODE:
#ifndef MAGIC_APPEND
                croak("getLastBlockOffset needs zlib 1.2.1 or better");
#else
                RETVAL = s->lastBlockOffset - (s->window_lastbit != 0);
#endif
    OUTPUT:
		RETVAL

uLong
getLastBufferOffset(s)
        Compress::Raw::Zlib::inflateScanStream	s
        CODE:
#ifndef MAGIC_APPEND
                croak("getLastBufferOffset needs zlib 1.2.1 or better");
#else
                RETVAL = s->window_lastoff;
#endif
    OUTPUT:
		RETVAL

void
resetLastBlockByte(s, byte)
        Compress::Raw::Zlib::inflateScanStream	s
        unsigned char*                      byte
        CODE:
#ifndef MAGIC_APPEND
                croak("resetLastBlockByte needs zlib 1.2.1 or better");
#else
                if (byte != NULL)
                        *byte = *byte ^ (1 << ((8 - s->window_lastbit) & 7));
#endif


void
_createDeflateStream(inf_s, flags,level, method, windowBits, memLevel, strategy, bufsize)
        Compress::Raw::Zlib::inflateScanStream	inf_s
        int flags
        int	level
        int method
        int windowBits
        int memLevel
        int strategy
        uLong bufsize
    PPCODE:
    {
#ifndef MAGIC_APPEND
                flags = flags;
                level = level ;
                method = method;
                windowBits = windowBits;
                memLevel = memLevel;
                strategy = strategy;
                bufsize= bufsize;
                croak("_createDeflateStream needs zlib 1.2.1 or better");
#else
        int err ;
        deflateStream s ;

        if (trace)
                warn("in _createDeflateStream(level=%d, method=%d, windowBits=%d, memLevel=%d, strategy=%d, bufsize=%lu\n",
		level, method, windowBits, memLevel, strategy, bufsize) ;
        if ((s = InitStream() )) {

                s->Level      = level;
                s->Method     = method;
        s->WindowBits = windowBits;
                s->MemLevel   = memLevel;
                s->Strategy   = strategy;

        err = CRZ_deflateInit2(&(s->stream), level,
			   			   method, windowBits, memLevel, strategy);

		if (err == Z_OK) {
	    	    err = CRZ_deflateSetDictionary(&(s->stream), inf_s->window, inf_s->window_have);
	    s->dict_adler = s->stream.adler ;
		}

                if (err != Z_OK) {
                        Safefree(s) ;
                        s = NULL ;
		}
		else {
	    	    PostInitStream(s, flags, bufsize, windowBits) ;
                        s->crc32            = inf_s->crc32;
            s->adler32          = inf_s->adler32;
                        s->stream.adler     = inf_s->stream.adler ;
            /* s->stream.total_out = inf_s->bytesInflated ; */
            s->stream.total_in  = inf_s->stream.total_out ;
                        if (inf_s->window_left) {
                /* printf("** window_left %d, window_lastByte %d\n", inf_s->window_left, inf_s->window_lastByte); */
                CRZ_deflatePrime(&(s->stream), 8 - inf_s->window_left, inf_s->window_lastByte);
            }
        }
    }
    else
        err = Z_MEM_ERROR ;

    XPUSHs(sv_setref_pv(sv_newmortal(),
            "Compress::Raw::Zlib::deflateStream", (void*)s));
        if (GIMME_V == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
        setDUALstatus(sv, err);
        XPUSHs(sv) ;
    }
#endif
  }

DualType
status(s)
                Compress::Raw::Zlib::inflateScanStream   s
        CODE:
		RETVAL = s->last_error ;
        OUTPUT:
		RETVAL

uLong
crc32(s)
                Compress::Raw::Zlib::inflateScanStream   s
        CODE:
		RETVAL = s->crc32 ;
        OUTPUT:
		RETVAL


uLong
adler32(s)
        Compress::Raw::Zlib::inflateScanStream   s
        CODE:
		RETVAL = s->adler32 ;
        OUTPUT:
		RETVAL