[p5sagit/p5-mst-13.2.git] / ext / Compress-Raw-Bzip2 / Bzip2.xs

/* Filename: Bzip2.xs
 * Author  : Paul Marquess, <pmqs@cpan.org>
 * Created : 5th October 2005
 * Version : 2.000
 *
 *   Copyright (c) 2005-2007 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.
 *
 */


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

#include "bzlib.h" 

#ifdef USE_PPPORT_H
#  define NEED_sv_2pv_nolen
#  include "ppport.h" 
#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 PERL_REVISION == 5 && (PERL_VERSION >= 8 || (PERL_VERSION == 8 && PERL_SUBVERSION < 4 ))
#    define UTF8_AVAILABLE
#endif

typedef int                     DualType ;
typedef int                     int_undef ;

typedef unsigned long           uLong;
typedef unsigned int            uInt;

typedef struct di_stream {
    int      flags ;
#define FLAG_APPEND_OUTPUT      1
#define FLAG_CONSUME_INPUT      8
    bz_stream stream;
    uInt     bufsize; 
    int      last_error ;
    uLong    bytesInflated ;
    uLong    compressedBytes ;
    uLong    uncompressedBytes ;
    
} di_stream;

typedef di_stream * deflateStream ;
typedef di_stream * Compress__Raw__Bzip2 ;

typedef di_stream * inflateStream ;
typedef di_stream * Compress__Raw__Bunzip2 ;

#define COMPRESS_CLASS    "Compress::Raw::Bzip2"
#define UNCOMPRESS_CLASS  "Compress::Raw::Bunzip2"

#define ZMALLOC(to, typ) ((to = (typ *)safemalloc(sizeof(typ))), \
                                Zero(to,1,typ))


/* static const char * const my_z_errmsg[] = { */
static const char my_z_errmsg[][32] = {
    "End of Stream",        /* BZ_STREAM_END        4       */
    "Finish OK",            /* BZ_FINISH_OK         3       */
    "Flush OK",             /* BZ_FLUSH_OK          2       */
    "Run OK",               /* BZ_RUN_OK            1       */
    "",                     /* BZ_OK                0       */
    "Sequence Error",       /* BZ_SEQUENCE_ERROR    (-1)    */
    "Param Error",          /* BZ_PARAM_ERROR       (-2)    */
    "Memory Error",         /* BZ_MEM_ERROR         (-3)    */
    "Data Error",           /* BZ_DATA_ERROR        (-4)    */
    "Magic Error",          /* BZ_DATA_ERROR_MAGIC  (-5)    */
    "IO Error",             /* BZ_IO_ERROR          (-6)    */
    "Unexpected EOF",       /* BZ_UNEXPECTED_EOF    (-7)    */
    "Output Buffer Full",   /* BZ_OUTBUFF_FULL      (-8)    */
    "Config Error",         /* BZ_CONFIG_ERROR      (-9)    */
    ""};

#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

#define TRACE_DEFAULT 0

#ifdef NO_WRITEABLE_DATA
#  define trace TRACE_DEFAULT
#else
  static int trace = TRACE_DEFAULT ;
#endif

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

#if 1
#define getInnerObject(x) (*av_fetch((AV*)SvRV(x), 0, FALSE))
#else
#define getInnerObject(x) ((SV*)SvRV(sv))
#endif

#ifdef BZ_NO_STDIO
void bz_internal_error(int errorcode)
{
    croak("bz_internal_error %d\n", errorcode);
}
#endif

static char *
#ifdef CAN_PROTOTYPE
GetErrorString(int error_no)
#else
GetErrorString(error_no)
int error_no ;
#endif
{
    dTHX;
    char * errstr ;
  
#if 0
    if (error_no == BZ_ERRNO) {
        errstr = Strerror(errno) ;
    }
    else
#endif
        errstr = (char*) my_z_errmsg[4 - error_no]; 

    return errstr ;
}

static void
#ifdef CAN_PROTOTYPE
DispHex(void * ptr, int length)
#else
DispHex(ptr, length)
    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, char * message)
#else
DispStream(s, message)
    di_stream * s;
    char * message;
#endif
{

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

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

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

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

        printf("           next_out  0x%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("    bufsize          %lu\n",  (unsigned long)s->bufsize);
        printf("    flags            0x%x\n", s->flags);
        printf("           APPEND    %s\n",   EnDis(FLAG_APPEND_OUTPUT));
        printf("           CONSUME   %s\n",   EnDis(FLAG_CONSUME_INPUT));

        printf("\n");

    }
}

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

    ZMALLOC(s, di_stream) ;

    return s ;
    
}

static void
#ifdef CAN_PROTOTYPE
PostInitStream(di_stream * s, int flags)
#else
PostInitStream(s, flags)
    di_stream *s ;
    int flags ;
#endif
{
    s->bufsize  = 1024 * 16 ;
    s->last_error = 0 ;
    s->flags    = flags ;
}


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);
        }
        if (SvROK(sv))
            croak("%s: buffer parameter is a reference to a reference", string) ;
    }

    if (!SvOK(sv)) { 
        sv = 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 ;
    
    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);
        }
        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)
        SvCUR_set(sv, 0);
    
    SvOOK_off(sv);
    SvPOK_only(sv);

    return sv ;
}


#include "constants.h"

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

REQUIRE:	1.924
PROTOTYPES:	DISABLE

INCLUDE: constants.xs

BOOT:
    /* Check this version of bzip2 is == 1 */
    if (BZ2_bzlibVersion()[0] != '1')
	croak(COMPRESS_CLASS " needs bzip2 version 1.x, you have %s\n", BZ2_bzlibVersion()) ;
	

MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2

#define bzlibversion() BZ2_bzlibVersion()
const char *
bzlibversion()

void
new(class, appendOut=1, blockSize100k=1, workfactor=0, verbosity=0)
    const char * class
    int appendOut
    int	blockSize100k
    int workfactor
    int verbosity
  PPCODE:
  {
    int err ;
    deflateStream s ;
#if 0
    /* if (trace) */
        warn("in Compress::Raw::Bzip2::_new(items=%d,appendOut=%d, blockSize100k=%d, workfactor=%d, verbosity=%d\n",
	items, appendOut, blockSize100k, workfactor, verbosity);
#endif
    if ((s = InitStream() )) {

        err = BZ2_bzCompressInit ( &(s->stream), 
                                     blockSize100k, 
                                     verbosity,
                                     workfactor );

        if (err != BZ_OK) {
            Safefree(s) ;
            s = NULL ;
	}
	else {
            int flags = 0 ;
            if (appendOut)
                flags |= FLAG_APPEND_OUTPUT;
            PostInitStream(s, appendOut ? FLAG_APPEND_OUTPUT :0) ;
        }
    }
    else
        err = BZ_MEM_ERROR ;

    {
        SV* obj = sv_setref_pv(sv_newmortal(), class, (void*)s);
        XPUSHs(obj);
    }
    if(0)
    {
        SV* obj = sv_2mortal(newSViv(PTR2IV(s))) ;
        XPUSHs(obj);
    }
    if (GIMME == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
	setDUALstatus(sv, err);
        XPUSHs(sv) ;
    }
  }

MODULE = Compress::Raw::Bunzip2 PACKAGE = Compress::Raw::Bunzip2

void
new(class, appendOut=1 , consume=1, small=0, verbosity=0)
    const char* class
    int appendOut
    int consume
    int small
    int verbosity
  PPCODE:
  {
    int err = BZ_OK ;
    inflateStream s ;
#if 0
    if (trace)
        warn("in _inflateInit(windowBits=%d, bufsize=%lu, dictionary=%lu\n",
                windowBits, bufsize, (unsigned long)SvCUR(dictionary)) ;
#endif
    if ((s = InitStream() )) {

        err = BZ2_bzDecompressInit (&(s->stream), verbosity, small);
        if (err != BZ_OK) {
            Safefree(s) ;
            s = NULL ;
	}
	if (s) {
            int flags = 0;
            if (appendOut)
                flags |= FLAG_APPEND_OUTPUT;
            if (consume)
                flags |= FLAG_CONSUME_INPUT;
	    PostInitStream(s, flags) ;
        }
    }
    else
	err = BZ_MEM_ERROR ;

    {
        SV* obj = sv_setref_pv(sv_newmortal(), class, (void*)s);
        XPUSHs(obj);
    }
       if (0)
    {
        SV* obj = sv_2mortal(newSViv(PTR2IV(s))) ;
        XPUSHs(obj);
    }
    if (GIMME == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
	setDUALstatus(sv, err);
        XPUSHs(sv) ;
    }
  }
 

MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2

void
DispStream(s, message=NULL)
    Compress::Raw::Bzip2   s
    char *  message

DualType 
bzdeflate (s, buf, output)
    Compress::Raw::Bzip2	s
    SV *	buf
    SV * 	output 
    uInt	cur_length = NO_INIT
    uInt	increment = NO_INIT
    int		RETVAL = 0;
    uInt   bufinc = NO_INIT
  CODE:
    bufinc = s->bufsize;

    /* 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_CLASS "::bzdeflate input parameter");
#endif         
    s->stream.next_in = (char*)SvPVbyte_nolen(buf) ;
    s->stream.avail_in = SvCUR(buf) ;
     
    /* 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_CLASS "::bzdeflate output parameter");
#endif         

    if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
        SvCUR_set(output, 0);
        /* sv_setpvn(output, "", 0); */
    }
    cur_length =  SvCUR(output) ;
    s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
    increment =  SvLEN(output) -  cur_length;
    s->stream.avail_out =  increment;
    while (s->stream.avail_in != 0) {

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

        RETVAL = BZ2_bzCompress(&(s->stream), BZ_RUN);
        if (RETVAL != BZ_RUN_OK) 
            break;
    }

    s->compressedBytes    += cur_length + increment - s->stream.avail_out ;
    s->uncompressedBytes  += SvCUR(buf) - s->stream.avail_in  ;

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

void
DESTROY(s)
    Compress::Raw::Bzip2	s
  CODE:
    BZ2_bzCompressEnd(&s->stream) ;
    Safefree(s) ;


DualType
bzclose(s, output)
    Compress::Raw::Bzip2	s
    SV * output 
    uInt	cur_length = NO_INIT
    uInt	increment = NO_INIT
    uInt    bufinc = NO_INIT
  CODE:
    bufinc = s->bufsize;
  
    s->stream.avail_in = 0; /* should be zero already anyway */
  
    /* retrieve the output buffer */
    output = deRef_l(output, "close") ;
#ifdef UTF8_AVAILABLE    
    if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
         croak("Wide character in " COMPRESS_CLASS "::bzclose input parameter");
#endif         
    if(! s->flags & FLAG_APPEND_OUTPUT) {
        SvCUR_set(output, 0);
        /* sv_setpvn(output, "", 0); */
    }
    cur_length =  SvCUR(output) ;
    s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
    increment =  SvLEN(output) -  cur_length;
    s->stream.avail_out =  increment;

    for (;;) {
        if (s->stream.avail_out == 0) {
	    /* consumed all the available output, so extend it */
            Sv_Grow(output, SvLEN(output) + bufinc) ;
            cur_length += increment ;
            s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length ;
            increment = bufinc ;
            s->stream.avail_out = increment;
            bufinc *= 2 ;
        }
        RETVAL = BZ2_bzCompress(&(s->stream), BZ_FINISH);
    
        /* 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 < 0 ) */
        if (RETVAL == BZ_STREAM_END || RETVAL < 0 )
            break;
    }
  
    /* RETVAL =  (RETVAL == BZ_STREAM_END ? BZ_OK : RETVAL) ; */
    s->last_error = RETVAL ;

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


DualType
bzflush(s, output)
    Compress::Raw::Bzip2	s
    SV * output 
    uInt	cur_length = NO_INIT
    uInt	increment = NO_INIT
    uInt    bufinc = NO_INIT
  CODE:
    bufinc = s->bufsize;
  
    s->stream.avail_in = 0; /* should be zero already anyway */
  
    /* retrieve the output buffer */
    output = deRef_l(output, "close") ;
#ifdef UTF8_AVAILABLE    
    if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
         croak("Wide character in " COMPRESS_CLASS "::bzflush input parameter");
#endif         
    if(! s->flags & FLAG_APPEND_OUTPUT) {
        SvCUR_set(output, 0);
        /* sv_setpvn(output, "", 0); */
    }
    cur_length =  SvCUR(output) ;
    s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
    increment =  SvLEN(output) -  cur_length;
    s->stream.avail_out =  increment;

    for (;;) {
        if (s->stream.avail_out == 0) {
	    /* consumed all the available output, so extend it */
            Sv_Grow(output, SvLEN(output) + bufinc) ;
            cur_length += increment ;
            s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length ;
            increment = bufinc ;
            s->stream.avail_out = increment;
            bufinc *= 2 ;
        }
        RETVAL = BZ2_bzCompress(&(s->stream), BZ_FLUSH);
    
        if (RETVAL == BZ_RUN_OK || RETVAL < 0)
                break;

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

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

uLong
total_in_lo32(s)
        Compress::Raw::Bzip2   s
    CODE:
        RETVAL = s->stream.total_in_lo32 ;
    OUTPUT:
	RETVAL

uLong
total_out_lo32(s)
        Compress::Raw::Bzip2   s
    CODE:
        RETVAL = s->stream.total_out_lo32 ;
    OUTPUT:
	RETVAL

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

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

        
MODULE = Compress::Raw::Bunzip2 PACKAGE = Compress::Raw::Bunzip2

void
DispStream(s, message=NULL)
    Compress::Raw::Bunzip2   s
    char *  message

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

    if (s->flags & FLAG_CONSUME_INPUT && SvREADONLY(buf))
        croak(UNCOMPRESS_CLASS "::bzinflate input parameter cannot be read-only when ConsumeInput is specified");
#ifdef UTF8_AVAILABLE    
    if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
         croak("Wide character in " UNCOMPRESS_CLASS "::bzinflate input parameter");
#endif         
    
    /* initialise the input buffer */
    s->stream.next_in = (char*)SvPVbyte_force(buf, stmp) ;
    s->stream.avail_in = SvCUR(buf);
	
    /* 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 " UNCOMPRESS_CLASS "::bzinflate output parameter");
#endif         
    if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
        SvCUR_set(output, 0);
    }
    if (SvLEN(output)) {
        prefix_length = cur_length =  SvCUR(output) ;
        s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
        increment = SvLEN(output) -  cur_length - 1;
        s->stream.avail_out = increment;
    }
    else {
        s->stream.avail_out = 0;
    }
    s->bytesInflated = 0;
    
    while (1) {

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

        RETVAL = BZ2_bzDecompress (&(s->stream));

        if (RETVAL != BZ_OK) 
            break ;

        if (s->stream.avail_out == 0)
            continue ;

        if (s->stream.avail_in == 0) {
            RETVAL = BZ_OK ;
            break ;
        }
	
    }
    
    s->last_error = RETVAL ;
    if (RETVAL == BZ_OK || RETVAL == BZ_STREAM_END) {
	unsigned in ;

        s->bytesInflated = cur_length + increment - s->stream.avail_out - prefix_length;
        s->uncompressedBytes += s->bytesInflated ;
        s->compressedBytes   += SvCUR(buf) - 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);

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

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


void
DESTROY(s)
    Compress::Raw::Bunzip2	s
  CODE:
    BZ2_bzDecompressEnd(&s->stream) ;
    Safefree(s) ;


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

uLong
total_in_lo32(s)
        Compress::Raw::Bunzip2   s
    CODE:
        RETVAL = s->stream.total_in_lo32 ;
    OUTPUT:
	RETVAL

uLong
total_out_lo32(s)
        Compress::Raw::Bunzip2   s
    CODE:
        RETVAL = s->stream.total_out_lo32 ;
    OUTPUT:
	RETVAL

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

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

MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2        PREFIX = Zip_
Commit	Line	Data
bdb7fd9f	1	/* Filename: Bzip2.xs
	2	* Author : Paul Marquess, <pmqs@cpan.org>
	3	* Created : 5th October 2005
	4	* Version : 2.000
	5	*
	6	* Copyright (c) 2005-2007 Paul Marquess. All rights reserved.
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the same terms as Perl itself.
	9	*
	10	*/
	11
	12
	13	#include "EXTERN.h"
	14	#include "perl.h"
	15	#include "XSUB.h"
	16
	17	#include "bzlib.h"
	18
	19	#ifdef USE_PPPORT_H
	20	# define NEED_sv_2pv_nolen
	21	# include "ppport.h"
	22	#endif
	23
	24	#if PERL_REVISION == 5 && (PERL_VERSION < 8 \|\| (PERL_VERSION == 8 && PERL_SUBVERSION < 4 ))
	25
	26	# ifdef SvPVbyte_force
	27	# undef SvPVbyte_force
	28	# endif
	29
	30	# define SvPVbyte_force(sv,lp) SvPV_force(sv,lp)
	31
	32	#endif
	33
	34	#ifndef SvPVbyte_nolen
	35	# define SvPVbyte_nolen SvPV_nolen
	36	#endif
	37
	38
	39	#if PERL_REVISION == 5 && (PERL_VERSION >= 8 \|\| (PERL_VERSION == 8 && PERL_SUBVERSION < 4 ))
	40	# define UTF8_AVAILABLE
	41	#endif
	42
	43	typedef int DualType ;
	44	typedef int int_undef ;
	45
	46	typedef unsigned long uLong;
	47	typedef unsigned int uInt;
	48
	49	typedef struct di_stream {
	50	int flags ;
	51	#define FLAG_APPEND_OUTPUT 1
	52	#define FLAG_CONSUME_INPUT 8
	53	bz_stream stream;
	54	uInt bufsize;
	55	int last_error ;
	56	uLong bytesInflated ;
	57	uLong compressedBytes ;
	58	uLong uncompressedBytes ;
	59
	60	} di_stream;
	61
	62	typedef di_stream * deflateStream ;
	63	typedef di_stream * Compress__Raw__Bzip2 ;
	64
65	typedef di_stream * inflateStream ;
66	typedef di_stream * Compress__Raw__Bunzip2 ;
67
68	#define COMPRESS_CLASS "Compress::Raw::Bzip2"
69	#define UNCOMPRESS_CLASS "Compress::Raw::Bunzip2"
70
71	#define ZMALLOC(to, typ) ((to = (typ *)safemalloc(sizeof(typ))), \
72	Zero(to,1,typ))
73
74
75	/* static const char * const my_z_errmsg[] = { */
76	static const char my_z_errmsg[][32] = {
77	"End of Stream", /* BZ_STREAM_END 4 */
78	"Finish OK", /* BZ_FINISH_OK 3 */
79	"Flush OK", /* BZ_FLUSH_OK 2 */
80	"Run OK", /* BZ_RUN_OK 1 */
81	"", /* BZ_OK 0 */
82	"Sequence Error", /* BZ_SEQUENCE_ERROR (-1) */
83	"Param Error", /* BZ_PARAM_ERROR (-2) */
84	"Memory Error", /* BZ_MEM_ERROR (-3) */
85	"Data Error", /* BZ_DATA_ERROR (-4) */
86	"Magic Error", /* BZ_DATA_ERROR_MAGIC (-5) */
87	"IO Error", /* BZ_IO_ERROR (-6) */
88	"Unexpected EOF", /* BZ_UNEXPECTED_EOF (-7) */
89	"Output Buffer Full", /* BZ_OUTBUFF_FULL (-8) */
90	"Config Error", /* BZ_CONFIG_ERROR (-9) */
91	""};
92
93	#define setDUALstatus(var, err) \
94	sv_setnv(var, (double)err) ; \
95	sv_setpv(var, ((err) ? GetErrorString(err) : "")) ; \
96	SvNOK_on(var);
97
98
99	#if defined(__SYMBIAN32__)
100	# define NO_WRITEABLE_DATA
101	#endif
102
103	#define TRACE_DEFAULT 0
104
105	#ifdef NO_WRITEABLE_DATA
106	# define trace TRACE_DEFAULT
107	#else
108	static int trace = TRACE_DEFAULT ;
109	#endif
110
111	/* Dodge PerlIO hiding of these functions. */
112	#undef printf
113
114	#if 1
115	#define getInnerObject(x) (av_fetch((AV)SvRV(x), 0, FALSE))
116	#else
117	#define getInnerObject(x) ((SV*)SvRV(sv))
118	#endif
119
120	#ifdef BZ_NO_STDIO
121	void bz_internal_error(int errorcode)
122	{
123	croak("bz_internal_error %d\n", errorcode);
124	}
125	#endif
126
127	static char *
128	#ifdef CAN_PROTOTYPE
129	GetErrorString(int error_no)
130	#else
131	GetErrorString(error_no)
132	int error_no ;
133	#endif
134	{
135	dTHX;
136	char * errstr ;
137
138	#if 0
139	if (error_no == BZ_ERRNO) {
140	errstr = Strerror(errno) ;
141	}
142	else
143	#endif
144	errstr = (char*) my_z_errmsg[4 - error_no];
145
146	return errstr ;
147	}
148
149	static void
150	#ifdef CAN_PROTOTYPE
151	DispHex(void * ptr, int length)
152	#else
153	DispHex(ptr, length)
154	void * ptr;
155	int length;
156	#endif
157	{
158	char * p = (char*)ptr;
159	int i;
160	for (i = 0; i < length; ++i) {
161	printf(" %02x", 0xFF & *(p+i));
162	}
163	}
164
165
166	static void
167	#ifdef CAN_PROTOTYPE
168	DispStream(di_stream * s, char * message)
169	#else
170	DispStream(s, message)
171	di_stream * s;
172	char * message;
173	#endif
174	{
175
176	#if 0
177	if (! trace)
178	return ;
179	#endif
180
181	#define EnDis(f) (s->flags & f ? "Enabled" : "Disabled")
182
183	printf("DispStream 0x%p", s) ;
184	if (message)
185	printf("- %s \n", message) ;
186	printf("\n") ;
187
188	if (!s) {
189	printf(" stream pointer is NULL\n");
190	}
191	else {
192	printf(" stream 0x%p\n", &(s->stream));
193	printf(" opaque 0x%p\n", s->stream.opaque);
194	printf(" next_in 0x%p", s->stream.next_in);
195	if (s->stream.next_in){
196	printf(" =>");
197	DispHex(s->stream.next_in, 4);
198	}
199	printf("\n");
200
201	printf(" next_out 0x%p", s->stream.next_out);
202	if (s->stream.next_out){
203	printf(" =>");
204	DispHex(s->stream.next_out, 4);
205	}
206	printf("\n");
207
208	printf(" avail_in %lu\n", (unsigned long)s->stream.avail_in);
209	printf(" avail_out %lu\n", (unsigned long)s->stream.avail_out);
210	printf(" bufsize %lu\n", (unsigned long)s->bufsize);
211	printf(" flags 0x%x\n", s->flags);
212	printf(" APPEND %s\n", EnDis(FLAG_APPEND_OUTPUT));
213	printf(" CONSUME %s\n", EnDis(FLAG_CONSUME_INPUT));
214
215	printf("\n");
216
217	}
218	}
219
220	static di_stream *
221	#ifdef CAN_PROTOTYPE
222	InitStream(void)
223	#else
224	InitStream()
225	#endif
226	{
227	di_stream *s ;
228
229	ZMALLOC(s, di_stream) ;
230
231	return s ;
232
233	}
234
235	static void
236	#ifdef CAN_PROTOTYPE
237	PostInitStream(di_stream * s, int flags)
238	#else
239	PostInitStream(s, flags)
240	di_stream *s ;
241	int flags ;
242	#endif
243	{
244	s->bufsize = 1024 * 16 ;
245	s->last_error = 0 ;
246	s->flags = flags ;
247	}
248
249
250	static SV*
251	#ifdef CAN_PROTOTYPE
252	deRef(SV * sv, const char * string)
253	#else
254	deRef(sv, string)
255	SV * sv ;
256	char * string;
257	#endif
258	{
259	dTHX;
260	SvGETMAGIC(sv);
261
262	if (SvROK(sv)) {
263	sv = SvRV(sv) ;
264	SvGETMAGIC(sv);
265	switch(SvTYPE(sv)) {
266	case SVt_PVAV:
267	case SVt_PVHV:
268	case SVt_PVCV:
269	croak("%s: buffer parameter is not a SCALAR reference", string);
270	}
271	if (SvROK(sv))
272	croak("%s: buffer parameter is a reference to a reference", string) ;
273	}
274
275	if (!SvOK(sv)) {
276	sv = newSVpv("", 0);
277	}
278
279	return sv ;
280	}
281
282	static SV*
283	#ifdef CAN_PROTOTYPE
284	deRef_l(SV * sv, const char * string)
285	#else
286	deRef_l(sv, string)
287	SV * sv ;
288	char * string ;
289	#endif
290	{
291	dTHX;
292	bool wipe = 0 ;
293
294	SvGETMAGIC(sv);
295	wipe = ! SvOK(sv) ;
296
297	if (SvROK(sv)) {
298	sv = SvRV(sv) ;
299	SvGETMAGIC(sv);
300	wipe = ! SvOK(sv) ;
301
302	switch(SvTYPE(sv)) {
303	case SVt_PVAV:
304	case SVt_PVHV:
305	case SVt_PVCV:
306	croak("%s: buffer parameter is not a SCALAR reference", string);
307	}
308	if (SvROK(sv))
309	croak("%s: buffer parameter is a reference to a reference", string) ;
310	}
311
312	if (SvREADONLY(sv) && PL_curcop != &PL_compiling)
313	croak("%s: buffer parameter is read-only", string);
314
315	SvUPGRADE(sv, SVt_PV);
316
317	if (wipe)
318	SvCUR_set(sv, 0);
319
320	SvOOK_off(sv);
321	SvPOK_only(sv);
322
323	return sv ;
324	}
325
326
327	#include "constants.h"
328
329	MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2 PREFIX = Zip_
330
331	REQUIRE: 1.924
332	PROTOTYPES: DISABLE
333
334	INCLUDE: constants.xs
335
336	BOOT:
337	/* Check this version of bzip2 is == 1 */
338	if (BZ2_bzlibVersion()[0] != '1')
339	croak(COMPRESS_CLASS " needs bzip2 version 1.x, you have %s\n", BZ2_bzlibVersion()) ;
340
341
342	MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2
343
344	#define bzlibversion() BZ2_bzlibVersion()
345	const char *
346	bzlibversion()
347
348	void
349	new(class, appendOut=1, blockSize100k=1, workfactor=0, verbosity=0)
350	const char * class
351	int appendOut
352	int blockSize100k
353	int workfactor
354	int verbosity
355	PPCODE:
356	{
357	int err ;
358	deflateStream s ;
359	#if 0
360	/* if (trace) */
361	warn("in Compress::Raw::Bzip2::_new(items=%d,appendOut=%d, blockSize100k=%d, workfactor=%d, verbosity=%d\n",
362	items, appendOut, blockSize100k, workfactor, verbosity);
363	#endif
364	if ((s = InitStream() )) {
365
366	err = BZ2_bzCompressInit ( &(s->stream),
367	blockSize100k,
368	verbosity,
369	workfactor );
370
371	if (err != BZ_OK) {
372	Safefree(s) ;
373	s = NULL ;
374	}
375	else {
376	int flags = 0 ;
377	if (appendOut)
378	flags \|= FLAG_APPEND_OUTPUT;
379	PostInitStream(s, appendOut ? FLAG_APPEND_OUTPUT :0) ;
380	}
381	}
382	else
383	err = BZ_MEM_ERROR ;
384
385	{
386	SV* obj = sv_setref_pv(sv_newmortal(), class, (void*)s);
387	XPUSHs(obj);
388	}
389	if(0)
390	{
391	SV* obj = sv_2mortal(newSViv(PTR2IV(s))) ;
392	XPUSHs(obj);
393	}
394	if (GIMME == G_ARRAY) {
395	SV * sv = sv_2mortal(newSViv(err)) ;
396	setDUALstatus(sv, err);
397	XPUSHs(sv) ;
398	}
399	}
400
401	MODULE = Compress::Raw::Bunzip2 PACKAGE = Compress::Raw::Bunzip2
402
403	void
404	new(class, appendOut=1 , consume=1, small=0, verbosity=0)
405	const char* class
406	int appendOut
407	int consume
408	int small
409	int verbosity
410	PPCODE:
411	{
412	int err = BZ_OK ;
413	inflateStream s ;
414	#if 0
415	if (trace)
416	warn("in _inflateInit(windowBits=%d, bufsize=%lu, dictionary=%lu\n",
417	windowBits, bufsize, (unsigned long)SvCUR(dictionary)) ;
418	#endif
419	if ((s = InitStream() )) {
420
421	err = BZ2_bzDecompressInit (&(s->stream), verbosity, small);
422	if (err != BZ_OK) {
423	Safefree(s) ;
424	s = NULL ;
425	}
426	if (s) {
427	int flags = 0;
428	if (appendOut)
429	flags \|= FLAG_APPEND_OUTPUT;
430	if (consume)
431	flags \|= FLAG_CONSUME_INPUT;
432	PostInitStream(s, flags) ;
433	}
434	}
435	else
436	err = BZ_MEM_ERROR ;
437
438	{
439	SV* obj = sv_setref_pv(sv_newmortal(), class, (void*)s);
440	XPUSHs(obj);
441	}
442	if (0)
443	{
444	SV* obj = sv_2mortal(newSViv(PTR2IV(s))) ;
445	XPUSHs(obj);
446	}
447	if (GIMME == G_ARRAY) {
448	SV * sv = sv_2mortal(newSViv(err)) ;
449	setDUALstatus(sv, err);
450	XPUSHs(sv) ;
451	}
452	}
453
454
455
456	MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2
457
458	void
459	DispStream(s, message=NULL)
460	Compress::Raw::Bzip2 s
461	char * message
462
463	DualType
464	bzdeflate (s, buf, output)
465	Compress::Raw::Bzip2 s
466	SV * buf
467	SV * output
468	uInt cur_length = NO_INIT
469	uInt increment = NO_INIT
470	int RETVAL = 0;
471	uInt bufinc = NO_INIT
472	CODE:
473	bufinc = s->bufsize;
474
475	/* If the input buffer is a reference, dereference it */
476	buf = deRef(buf, "deflate") ;
477
478	/* initialise the input buffer */
479	#ifdef UTF8_AVAILABLE
480	if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
481	croak("Wide character in " COMPRESS_CLASS "::bzdeflate input parameter");
482	#endif
483	s->stream.next_in = (char*)SvPVbyte_nolen(buf) ;
484	s->stream.avail_in = SvCUR(buf) ;
485
486	/* and retrieve the output buffer */
487	output = deRef_l(output, "deflate") ;
488	#ifdef UTF8_AVAILABLE
489	if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
490	croak("Wide character in " COMPRESS_CLASS "::bzdeflate output parameter");
491	#endif
492
493	if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
494	SvCUR_set(output, 0);
495	/* sv_setpvn(output, "", 0); */
496	}
497	cur_length = SvCUR(output) ;
498	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
499	increment = SvLEN(output) - cur_length;
500	s->stream.avail_out = increment;
501	while (s->stream.avail_in != 0) {
502
503	if (s->stream.avail_out == 0) {
504	/* out of space in the output buffer so make it bigger */
505	Sv_Grow(output, SvLEN(output) + bufinc) ;
506	cur_length += increment ;
507	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length ;
508	increment = bufinc ;
509	s->stream.avail_out = increment;
510	bufinc *= 2 ;
511	}
512
513	RETVAL = BZ2_bzCompress(&(s->stream), BZ_RUN);
514	if (RETVAL != BZ_RUN_OK)
515	break;
516	}
517
518	s->compressedBytes += cur_length + increment - s->stream.avail_out ;
519	s->uncompressedBytes += SvCUR(buf) - s->stream.avail_in ;
520
521	s->last_error = RETVAL ;
522	if (RETVAL == BZ_RUN_OK) {
523	SvPOK_only(output);
524	SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
525	SvSETMAGIC(output);
526	}
527	OUTPUT:
528	RETVAL
529
530
531	void
532	DESTROY(s)
533	Compress::Raw::Bzip2 s
534	CODE:
535	BZ2_bzCompressEnd(&s->stream) ;
536	Safefree(s) ;
537
538
539	DualType
540	bzclose(s, output)
541	Compress::Raw::Bzip2 s
542	SV * output
543	uInt cur_length = NO_INIT
544	uInt increment = NO_INIT
545	uInt bufinc = NO_INIT
546	CODE:
547	bufinc = s->bufsize;
548
549	s->stream.avail_in = 0; /* should be zero already anyway */
550
551	/* retrieve the output buffer */
552	output = deRef_l(output, "close") ;
553	#ifdef UTF8_AVAILABLE
554	if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
555	croak("Wide character in " COMPRESS_CLASS "::bzclose input parameter");
556	#endif
557	if(! s->flags & FLAG_APPEND_OUTPUT) {
558	SvCUR_set(output, 0);
559	/* sv_setpvn(output, "", 0); */
560	}
561	cur_length = SvCUR(output) ;
562	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
563	increment = SvLEN(output) - cur_length;
564	s->stream.avail_out = increment;
565
566	for (;;) {
567	if (s->stream.avail_out == 0) {
568	/* consumed all the available output, so extend it */
569	Sv_Grow(output, SvLEN(output) + bufinc) ;
570	cur_length += increment ;
571	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length ;
572	increment = bufinc ;
573	s->stream.avail_out = increment;
574	bufinc *= 2 ;
575	}
576	RETVAL = BZ2_bzCompress(&(s->stream), BZ_FINISH);
577
578	/* deflate has finished flushing only when it hasn't used up
579	* all the available space in the output buffer:
580	*/
581	/* if (s->stream.avail_out != 0 \|\| RETVAL < 0 ) */
582	if (RETVAL == BZ_STREAM_END \|\| RETVAL < 0 )
583	break;
584	}
585
586	/* RETVAL = (RETVAL == BZ_STREAM_END ? BZ_OK : RETVAL) ; */
587	s->last_error = RETVAL ;
588
589	s->compressedBytes += cur_length + increment - s->stream.avail_out ;
590
591	if (RETVAL == BZ_STREAM_END) {
592	SvPOK_only(output);
593	SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
594	SvSETMAGIC(output);
595	}
596	OUTPUT:
597	RETVAL
598
599
600	DualType
601	bzflush(s, output)
602	Compress::Raw::Bzip2 s
603	SV * output
604	uInt cur_length = NO_INIT
605	uInt increment = NO_INIT
606	uInt bufinc = NO_INIT
607	CODE:
608	bufinc = s->bufsize;
609
610	s->stream.avail_in = 0; /* should be zero already anyway */
611
612	/* retrieve the output buffer */
613	output = deRef_l(output, "close") ;
614	#ifdef UTF8_AVAILABLE
615	if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
616	croak("Wide character in " COMPRESS_CLASS "::bzflush input parameter");
617	#endif
618	if(! s->flags & FLAG_APPEND_OUTPUT) {
619	SvCUR_set(output, 0);
620	/* sv_setpvn(output, "", 0); */
621	}
622	cur_length = SvCUR(output) ;
623	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
624	increment = SvLEN(output) - cur_length;
625	s->stream.avail_out = increment;
626
627	for (;;) {
628	if (s->stream.avail_out == 0) {
629	/* consumed all the available output, so extend it */
630	Sv_Grow(output, SvLEN(output) + bufinc) ;
631	cur_length += increment ;
632	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length ;
633	increment = bufinc ;
634	s->stream.avail_out = increment;
635	bufinc *= 2 ;
636	}
637	RETVAL = BZ2_bzCompress(&(s->stream), BZ_FLUSH);
638
639	if (RETVAL == BZ_RUN_OK \|\| RETVAL < 0)
640	break;
641
642	/* deflate has finished flushing only when it hasn't used up
643	* all the available space in the output buffer:
644	*/
645	/* RETVAL == if (s->stream.avail_out != 0 \|\| RETVAL < 0 )
646	break; */
647	}
648
649	/* RETVAL = (RETVAL == BZ_STREAM_END ? BZ_OK : RETVAL) ; */
650	s->last_error = RETVAL ;
651
652	s->compressedBytes += cur_length + increment - s->stream.avail_out ;
653
654	if (RETVAL == BZ_RUN_OK) {
655	SvPOK_only(output);
656	SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
657	SvSETMAGIC(output);
658	}
659	OUTPUT:
660	RETVAL
661
662	uLong
663	total_in_lo32(s)
664	Compress::Raw::Bzip2 s
665	CODE:
666	RETVAL = s->stream.total_in_lo32 ;
667	OUTPUT:
668	RETVAL
669
670	uLong
671	total_out_lo32(s)
672	Compress::Raw::Bzip2 s
673	CODE:
674	RETVAL = s->stream.total_out_lo32 ;
675	OUTPUT:
676	RETVAL
677
678	uLong
679	compressedBytes(s)
680	Compress::Raw::Bzip2 s
681	CODE:
682	RETVAL = s->compressedBytes;
683	OUTPUT:
684	RETVAL
685
686	uLong
687	uncompressedBytes(s)
688	Compress::Raw::Bzip2 s
689	CODE:
690	RETVAL = s->uncompressedBytes;
691	OUTPUT:
692	RETVAL
693
694
695	MODULE = Compress::Raw::Bunzip2 PACKAGE = Compress::Raw::Bunzip2
696
697	void
698	DispStream(s, message=NULL)
699	Compress::Raw::Bunzip2 s
700	char * message
701
702	DualType
703	bzinflate (s, buf, output)
704	Compress::Raw::Bunzip2 s
705	SV * buf
706	SV * output
707	uInt cur_length = 0;
708	uInt prefix_length = 0;
709	uInt increment = 0;
710	STRLEN stmp = NO_INIT
711	uInt bufinc = NO_INIT
712	PREINIT:
713	#ifdef UTF8_AVAILABLE
714	bool out_utf8 = FALSE;
715	#endif
716	CODE:
717	bufinc = s->bufsize;
718	/* If the buffer is a reference, dereference it */
719	buf = deRef(buf, "inflate") ;
720
721	if (s->flags & FLAG_CONSUME_INPUT && SvREADONLY(buf))
722	croak(UNCOMPRESS_CLASS "::bzinflate input parameter cannot be read-only when ConsumeInput is specified");
723	#ifdef UTF8_AVAILABLE
724	if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
725	croak("Wide character in " UNCOMPRESS_CLASS "::bzinflate input parameter");
726	#endif
727
728	/* initialise the input buffer */
729	s->stream.next_in = (char*)SvPVbyte_force(buf, stmp) ;
730	s->stream.avail_in = SvCUR(buf);
731
732	/* and retrieve the output buffer */
733	output = deRef_l(output, "inflate") ;
734	#ifdef UTF8_AVAILABLE
735	if (DO_UTF8(output))
736	out_utf8 = TRUE ;
737	if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
738	croak("Wide character in " UNCOMPRESS_CLASS "::bzinflate output parameter");
739	#endif
740	if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
741	SvCUR_set(output, 0);
742	}
743	if (SvLEN(output)) {
744	prefix_length = cur_length = SvCUR(output) ;
745	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length;
746	increment = SvLEN(output) - cur_length - 1;
747	s->stream.avail_out = increment;
748	}
749	else {
750	s->stream.avail_out = 0;
751	}
752	s->bytesInflated = 0;
753
754	while (1) {
755
756	if (s->stream.avail_out == 0) {
757	/* out of space in the output buffer so make it bigger */
758	Sv_Grow(output, SvLEN(output) + bufinc) ;
759	cur_length += increment ;
760	s->stream.next_out = (char*) SvPVbyte_nolen(output) + cur_length ;
761	increment = bufinc ;
762	s->stream.avail_out = increment;
763	bufinc *= 2 ;
764	}
765
766	RETVAL = BZ2_bzDecompress (&(s->stream));
767
768	if (RETVAL != BZ_OK)
769	break ;
770
771	if (s->stream.avail_out == 0)
772	continue ;
773
774	if (s->stream.avail_in == 0) {
775	RETVAL = BZ_OK ;
776	break ;
777	}
778
779	}
780
781	s->last_error = RETVAL ;
782	if (RETVAL == BZ_OK \|\| RETVAL == BZ_STREAM_END) {
783	unsigned in ;
784
785	s->bytesInflated = cur_length + increment - s->stream.avail_out - prefix_length;
786	s->uncompressedBytes += s->bytesInflated ;
787	s->compressedBytes += SvCUR(buf) - s->stream.avail_in ;
788
789	SvPOK_only(output);
790	SvCUR_set(output, prefix_length + s->bytesInflated) ;
791	*SvEND(output) = '\0';
792	#ifdef UTF8_AVAILABLE
793	if (out_utf8)
794	sv_utf8_upgrade(output);
795	#endif
796	SvSETMAGIC(output);
797
798	/* fix the input buffer */
799	if (s->flags & FLAG_CONSUME_INPUT) {
800	in = s->stream.avail_in ;
801	SvCUR_set(buf, in) ;
802	if (in)
803	Move(s->stream.next_in, SvPVbyte_nolen(buf), in, char) ;
804	*SvEND(buf) = '\0';
805	SvSETMAGIC(buf);
806	}
807	}
808	OUTPUT:
809	RETVAL
810
811	uLong
812	inflateCount(s)
813	Compress::Raw::Bunzip2 s
814	CODE:
815	RETVAL = s->bytesInflated;
816	OUTPUT:
817	RETVAL
818
819
820	void
821	DESTROY(s)
822	Compress::Raw::Bunzip2 s
823	CODE:
824	BZ2_bzDecompressEnd(&s->stream) ;
825	Safefree(s) ;
826
827
828	uLong
829	status(s)
830	Compress::Raw::Bunzip2 s
831	CODE:
832	RETVAL = s->last_error ;
833	OUTPUT:
834	RETVAL
835
836	uLong
837	total_in_lo32(s)
838	Compress::Raw::Bunzip2 s
839	CODE:
840	RETVAL = s->stream.total_in_lo32 ;
841	OUTPUT:
842	RETVAL
843
844	uLong
845	total_out_lo32(s)
846	Compress::Raw::Bunzip2 s
847	CODE:
848	RETVAL = s->stream.total_out_lo32 ;
849	OUTPUT:
850	RETVAL
851
852	uLong
853	compressedBytes(s)
854	Compress::Raw::Bunzip2 s
855	CODE:
856	RETVAL = s->compressedBytes;
857	OUTPUT:
858	RETVAL
859
860	uLong
861	uncompressedBytes(s)
862	Compress::Raw::Bunzip2 s
863	CODE:
864	RETVAL = s->uncompressedBytes;
865	OUTPUT:
866	RETVAL
867
868	MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2 PREFIX = Zip_