cpan/Compress-Raw-Bzip2/Bzip2.xs

   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-2010 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 #define PERL_NO_GET_CONTEXT
  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 #define FLAG_LIMIT_OUTPUT       16
  54     bz_stream stream;
  55     uInt     bufsize;
  56     int      last_error ;
  57     uLong    bytesInflated ;
  58     uLong    compressedBytes ;
  59     uLong    uncompressedBytes ;
  60
  61 } di_stream;
  62
  63 typedef di_stream * deflateStream ;
  64 typedef di_stream * Compress__Raw__Bzip2 ;
  65
  66 typedef di_stream * inflateStream ;
  67 typedef di_stream * Compress__Raw__Bunzip2 ;
  68
  69 #define COMPRESS_CLASS    "Compress::Raw::Bzip2"
  70 #define UNCOMPRESS_CLASS  "Compress::Raw::Bunzip2"
  71
  72 #define ZMALLOC(to, typ) ((to = (typ *)safemalloc(sizeof(typ))), \
  73                                 Zero(to,1,typ))
  74
  75
  76 /* static const char * const my_z_errmsg[] = { */
  77 static const char my_z_errmsg[][32] = {
  78     "End of Stream",        /* BZ_STREAM_END        4       */
  79     "Finish OK",            /* BZ_FINISH_OK         3       */
  80     "Flush OK",             /* BZ_FLUSH_OK          2       */
  81     "Run OK",               /* BZ_RUN_OK            1       */
  82     "",                     /* BZ_OK                0       */
  83     "Sequence Error",       /* BZ_SEQUENCE_ERROR    (-1)    */
  84     "Param Error",          /* BZ_PARAM_ERROR       (-2)    */
  85     "Memory Error",         /* BZ_MEM_ERROR         (-3)    */
  86     "Data Error",           /* BZ_DATA_ERROR        (-4)    */
  87     "Magic Error",          /* BZ_DATA_ERROR_MAGIC  (-5)    */
  88     "IO Error",             /* BZ_IO_ERROR          (-6)    */
  89     "Unexpected EOF",       /* BZ_UNEXPECTED_EOF    (-7)    */
  90     "Output Buffer Full",   /* BZ_OUTBUFF_FULL      (-8)    */
  91     "Config Error",         /* BZ_CONFIG_ERROR      (-9)    */
  92     ""};
  93
  94 #define setDUALstatus(var, err)                                         \
  95                 sv_setnv(var, (double)err) ;                            \
  96                 sv_setpv(var, ((err) ? GetErrorString(err) : "")) ;     \
  97                 SvNOK_on(var);
  98
  99
 100 #if defined(__SYMBIAN32__)
 101 # define NO_WRITEABLE_DATA
 102 #endif
 103
 104 /* Set TRACE_DEFAULT to a non-zero value to enable tracing */
 105 #define TRACE_DEFAULT 0
 106
 107 #if defined(NO_WRITEABLE_DATA) || TRACE_DEFAULT == 0
 108 #  define trace TRACE_DEFAULT
 109 #else
 110   static int trace = TRACE_DEFAULT ;
 111 #endif
 112
 113 /* Dodge PerlIO hiding of these functions. */
 114 #undef printf
 115
 116 #if 1
 117 #define getInnerObject(x) (*av_fetch((AV*)SvRV(x), 0, FALSE))
 118 #else
 119 #define getInnerObject(x) ((SV*)SvRV(sv))
 120 #endif
 121
 122 #ifdef BZ_NO_STDIO
 123 void bz_internal_error(int errorcode)
 124 {
 125     croak("bz_internal_error %d\n", errorcode);
 126 }
 127 #endif
 128
 129 static char *
 130 #ifdef CAN_PROTOTYPE
 131 GetErrorString(int error_no)
 132 #else
 133 GetErrorString(error_no)
 134 int error_no ;
 135 #endif
 136 {
 137     return(char*) my_z_errmsg[4 - error_no];
 138 }
 139
 140 static void
 141 #ifdef CAN_PROTOTYPE
 142 DispHex(void * ptr, int length)
 143 #else
 144 DispHex(ptr, length)
 145     void * ptr;
 146     int length;
 147 #endif
 148 {
 149     char * p = (char*)ptr;
 150     int i;
 151     for (i = 0; i < length; ++i) {
 152         printf(" %02x", 0xFF & *(p+i));
 153     }
 154 }
 155
 156
 157 static void
 158 #ifdef CAN_PROTOTYPE
 159 DispStream(di_stream * s, const char * message)
 160 #else
 161 DispStream(s, message)
 162     di_stream * s;
 163     const char * message;
 164 #endif
 165 {
 166
 167 #if 0
 168     if (! trace)
 169         return ;
 170 #endif
 171
 172 #define EnDis(f) (s->flags & f ? "Enabled" : "Disabled")
 173
 174     printf("DispStream 0x%p", s) ;
 175     if (message)
 176         printf(" - %s \n", message) ;
 177     printf("\n") ;
 178
 179     if (!s)  {
 180         printf("    stream pointer is NULL\n");
 181     }
 182     else     {
 183         printf("    stream           0x%p\n", &(s->stream));
 184         printf("           opaque    0x%p\n", s->stream.opaque);
 185         printf("           state     0x%p\n", s->stream.state );
 186         printf("           next_in   0x%p", s->stream.next_in);
 187         if (s->stream.next_in){
 188             printf(" =>");
 189             DispHex(s->stream.next_in, 4);
 190         }
 191         printf("\n");
 192
 193         printf("           next_out  0x%p", s->stream.next_out);
 194         if (s->stream.next_out){
 195             printf(" =>");
 196             DispHex(s->stream.next_out, 4);
 197         }
 198         printf("\n");
 199
 200         printf("           avail_in  %lu\n",  (unsigned long)s->stream.avail_in);
 201         printf("           avail_out %lu\n",  (unsigned long)s->stream.avail_out);
 202         printf("    bufsize          %lu\n",  (unsigned long)s->bufsize);
 203         printf("      total_in_lo32  %u\n",  s->stream.total_in_lo32);
 204         printf("      total_in_hi32  %u\n",  s->stream.total_in_hi32);
 205         printf("      total_out_lo32 %u\n",  s->stream.total_out_lo32);
 206         printf("      total_out_hi32 %u\n",  s->stream.total_out_hi32);
 207         printf("    flags            0x%x\n", s->flags);
 208         printf("           APPEND    %s\n",   EnDis(FLAG_APPEND_OUTPUT));
 209         printf("           CONSUME   %s\n",   EnDis(FLAG_CONSUME_INPUT));
 210         printf("           LIMIT     %s\n",   EnDis(FLAG_LIMIT_OUTPUT));
 211
 212         printf("\n");
 213
 214     }
 215 }
 216
 217 static di_stream *
 218 #ifdef CAN_PROTOTYPE
 219 InitStream(void)
 220 #else
 221 InitStream()
 222 #endif
 223 {
 224     di_stream *s ;
 225
 226     ZMALLOC(s, di_stream) ;
 227
 228     return s ;
 229
 230 }
 231
 232 static void
 233 #ifdef CAN_PROTOTYPE
 234 PostInitStream(di_stream * s, int flags)
 235 #else
 236 PostInitStream(s, flags)
 237     di_stream *s ;
 238     int flags ;
 239 #endif
 240 {
 241     s->bufsize  = 1024 * 16 ;
 242     s->last_error = 0 ;
 243     s->flags    = flags ;
 244 }
 245
 246
 247 static SV*
 248 #ifdef CAN_PROTOTYPE
 249 deRef(SV * sv, const char * string)
 250 #else
 251 deRef(sv, string)
 252 SV * sv ;
 253 char * string;
 254 #endif
 255 {
 256     dTHX;
 257     SvGETMAGIC(sv);
 258
 259     if (SvROK(sv)) {
 260         sv = SvRV(sv) ;
 261         SvGETMAGIC(sv);
 262         switch(SvTYPE(sv)) {
 263             case SVt_PVAV:
 264             case SVt_PVHV:
 265             case SVt_PVCV:
 266                 croak("%s: buffer parameter is not a SCALAR reference", string);
 267             default:
 268                 break;
 269         }
 270         if (SvROK(sv))
 271             croak("%s: buffer parameter is a reference to a reference", string) ;
 272     }
 273
 274     if (!SvOK(sv))
 275         sv = sv_2mortal(newSVpv("", 0));
 276
 277     return sv ;
 278 }
 279
 280 static SV*
 281 #ifdef CAN_PROTOTYPE
 282 deRef_l(SV * sv, const char * string)
 283 #else
 284 deRef_l(sv, string)
 285 SV * sv ;
 286 char * string ;
 287 #endif
 288 {
 289     dTHX;
 290     bool wipe = 0 ;
 291     STRLEN na;
 292
 293     SvGETMAGIC(sv);
 294     wipe = ! SvOK(sv) ;
 295
 296     if (SvROK(sv)) {
 297         sv = SvRV(sv) ;
 298         SvGETMAGIC(sv);
 299         wipe = ! SvOK(sv) ;
 300
 301         switch(SvTYPE(sv)) {
 302             case SVt_PVAV:
 303             case SVt_PVHV:
 304             case SVt_PVCV:
 305                 croak("%s: buffer parameter is not a SCALAR reference", string);
 306             default:
 307                 break;
 308         }
 309         if (SvROK(sv))
 310             croak("%s: buffer parameter is a reference to a reference", string) ;
 311     }
 312
 313     if (SvREADONLY(sv) && PL_curcop != &PL_compiling)
 314         croak("%s: buffer parameter is read-only", string);
 315
 316     SvUPGRADE(sv, SVt_PV);
 317
 318     if (wipe)
 319         sv_setpv(sv, "") ;
 320     else
 321         (void)SvPVbyte_force(sv, na) ;
 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(className, appendOut=1, blockSize100k=1, workfactor=0, verbosity=0)
 350     const char * className
 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(), className, (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(className, appendOut=1 , consume=1, small=0, verbosity=0, limitOutput=0)
 405     const char* className
 406     int appendOut
 407     int consume
 408     int small
 409     int verbosity
 410     int limitOutput
 411   PPCODE:
 412   {
 413     int err = BZ_OK ;
 414     inflateStream s ;
 415 #if 0
 416     if (trace)
 417         warn("in _inflateInit(windowBits=%d, bufsize=%lu, dictionary=%lu\n",
 418                 windowBits, bufsize, (unsigned long)SvCUR(dictionary)) ;
 419 #endif
 420     if ((s = InitStream() )) {
 421
 422         err = BZ2_bzDecompressInit (&(s->stream), verbosity, small);
 423         if (err != BZ_OK) {
 424             Safefree(s) ;
 425             s = NULL ;
 426         }
 427         if (s) {
 428             int flags = 0;
 429             if (appendOut)
 430                 flags |= FLAG_APPEND_OUTPUT;
 431             if (consume)
 432                 flags |= FLAG_CONSUME_INPUT;
 433             if (limitOutput)
 434                 flags |= (FLAG_LIMIT_OUTPUT|FLAG_CONSUME_INPUT);
 435             PostInitStream(s, flags) ;
 436         }
 437     }
 438     else
 439         err = BZ_MEM_ERROR ;
 440
 441     {
 442         SV* obj = sv_setref_pv(sv_newmortal(), className, (void*)s);
 443         XPUSHs(obj);
 444     }
 445        if (0)
 446     {
 447         SV* obj = sv_2mortal(newSViv(PTR2IV(s))) ;
 448         XPUSHs(obj);
 449     }
 450     if (GIMME == G_ARRAY) {
 451         SV * sv = sv_2mortal(newSViv(err)) ;
 452         setDUALstatus(sv, err);
 453         XPUSHs(sv) ;
 454     }
 455   }
 456
 457
 458
 459 MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2
 460
 461 void
 462 DispStream(s, message=NULL)
 463     Compress::Raw::Bzip2   s
 464     const char *  message
 465
 466 DualType
 467 bzdeflate (s, buf, output)
 468     Compress::Raw::Bzip2        s
 469     SV *        buf
 470     SV *        output
 471     uInt        cur_length = NO_INIT
 472     uInt        increment = NO_INIT
 473     int         RETVAL = 0;
 474     uInt   bufinc = NO_INIT
 475     STRLEN   origlen = NO_INIT
 476   CODE:
 477     bufinc = s->bufsize;
 478
 479     /* If the input buffer is a reference, dereference it */
 480     buf = deRef(buf, "deflate") ;
 481
 482     /* initialise the input buffer */
 483 #ifdef UTF8_AVAILABLE
 484     if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
 485          croak("Wide character in " COMPRESS_CLASS "::bzdeflate input parameter");
 486 #endif
 487     s->stream.next_in = (char*)SvPV_nomg(buf, origlen) ;
 488     s->stream.avail_in = origlen;
 489
 490     /* and retrieve the output buffer */
 491     output = deRef_l(output, "deflate") ;
 492 #ifdef UTF8_AVAILABLE
 493     if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
 494          croak("Wide character in " COMPRESS_CLASS "::bzdeflate output parameter");
 495 #endif
 496
 497     if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
 498         SvCUR_set(output, 0);
 499         /* sv_setpvn(output, "", 0); */
 500     }
 501     cur_length =  SvCUR(output) ;
 502     s->stream.next_out = (char*) SvPVX(output) + cur_length;
 503     increment =  SvLEN(output) -  cur_length;
 504     s->stream.avail_out =  increment;
 505     while (s->stream.avail_in != 0) {
 506
 507         if (s->stream.avail_out == 0) {
 508             /* out of space in the output buffer so make it bigger */
 509             s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc) ;
 510             cur_length += increment ;
 511             s->stream.next_out += cur_length ;
 512             increment = bufinc ;
 513             s->stream.avail_out = increment;
 514             bufinc *= 2 ;
 515         }
 516
 517         RETVAL = BZ2_bzCompress(&(s->stream), BZ_RUN);
 518         if (RETVAL != BZ_RUN_OK)
 519             break;
 520     }
 521
 522     s->compressedBytes    += cur_length + increment - s->stream.avail_out ;
 523     s->uncompressedBytes  += origlen - s->stream.avail_in  ;
 524
 525     s->last_error = RETVAL ;
 526     if (RETVAL == BZ_RUN_OK) {
 527         SvPOK_only(output);
 528         SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
 529         SvSETMAGIC(output);
 530     }
 531     OUTPUT:
 532         RETVAL
 533
 534
 535 void
 536 DESTROY(s)
 537     Compress::Raw::Bzip2        s
 538   CODE:
 539     BZ2_bzCompressEnd(&s->stream) ;
 540     Safefree(s) ;
 541
 542
 543 DualType
 544 bzclose(s, output)
 545     Compress::Raw::Bzip2        s
 546     SV * output
 547     uInt        cur_length = NO_INIT
 548     uInt        increment = NO_INIT
 549     uInt    bufinc = NO_INIT
 550   CODE:
 551     bufinc = s->bufsize;
 552
 553     s->stream.avail_in = 0; /* should be zero already anyway */
 554
 555     /* retrieve the output buffer */
 556     output = deRef_l(output, "close") ;
 557 #ifdef UTF8_AVAILABLE
 558     if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
 559          croak("Wide character in " COMPRESS_CLASS "::bzclose input parameter");
 560 #endif
 561     if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
 562         SvCUR_set(output, 0);
 563         /* sv_setpvn(output, "", 0); */
 564     }
 565     cur_length =  SvCUR(output) ;
 566     s->stream.next_out = (char*) SvPVX(output) + cur_length;
 567     increment =  SvLEN(output) -  cur_length;
 568     s->stream.avail_out =  increment;
 569
 570     for (;;) {
 571         if (s->stream.avail_out == 0) {
 572             /* consumed all the available output, so extend it */
 573             s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc) ;
 574             cur_length += increment ;
 575             s->stream.next_out += cur_length ;
 576             increment = bufinc ;
 577             s->stream.avail_out = increment;
 578             bufinc *= 2 ;
 579         }
 580         RETVAL = BZ2_bzCompress(&(s->stream), BZ_FINISH);
 581
 582         /* deflate has finished flushing only when it hasn't used up
 583          * all the available space in the output buffer:
 584          */
 585         /* if (s->stream.avail_out != 0 || RETVAL < 0 ) */
 586         if (RETVAL == BZ_STREAM_END || RETVAL < 0 )
 587             break;
 588     }
 589
 590     /* RETVAL =  (RETVAL == BZ_STREAM_END ? BZ_OK : RETVAL) ; */
 591     s->last_error = RETVAL ;
 592
 593     s->compressedBytes    += cur_length + increment - s->stream.avail_out ;
 594
 595     if (RETVAL == BZ_STREAM_END) {
 596         SvPOK_only(output);
 597         SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
 598         SvSETMAGIC(output);
 599     }
 600     OUTPUT:
 601         RETVAL
 602
 603
 604 DualType
 605 bzflush(s, output)
 606     Compress::Raw::Bzip2        s
 607     SV * output
 608     uInt        cur_length = NO_INIT
 609     uInt        increment = NO_INIT
 610     uInt    bufinc = NO_INIT
 611   CODE:
 612     bufinc = s->bufsize;
 613
 614     s->stream.avail_in = 0; /* should be zero already anyway */
 615
 616     /* retrieve the output buffer */
 617     output = deRef_l(output, "close") ;
 618 #ifdef UTF8_AVAILABLE
 619     if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
 620          croak("Wide character in " COMPRESS_CLASS "::bzflush input parameter");
 621 #endif
 622     if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
 623         SvCUR_set(output, 0);
 624         /* sv_setpvn(output, "", 0); */
 625     }
 626     cur_length =  SvCUR(output) ;
 627     s->stream.next_out = (char*) SvPVX(output) + cur_length;
 628     increment =  SvLEN(output) -  cur_length;
 629     s->stream.avail_out =  increment;
 630
 631     for (;;) {
 632         if (s->stream.avail_out == 0) {
 633             /* consumed all the available output, so extend it */
 634             s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc) ;
 635             cur_length += increment ;
 636             s->stream.next_out += cur_length ;
 637             increment = bufinc ;
 638             s->stream.avail_out = increment;
 639             bufinc *= 2 ;
 640         }
 641         RETVAL = BZ2_bzCompress(&(s->stream), BZ_FLUSH);
 642
 643         if (RETVAL == BZ_RUN_OK || RETVAL < 0)
 644                 break;
 645
 646         /* deflate has finished flushing only when it hasn't used up
 647          * all the available space in the output buffer:
 648          */
 649         /* RETVAL == if (s->stream.avail_out != 0 || RETVAL < 0 )
 650             break; */
 651     }
 652
 653     /* RETVAL =  (RETVAL == BZ_STREAM_END ? BZ_OK : RETVAL) ; */
 654     s->last_error = RETVAL ;
 655
 656     s->compressedBytes    += cur_length + increment - s->stream.avail_out ;
 657
 658     if (RETVAL == BZ_RUN_OK) {
 659         SvPOK_only(output);
 660         SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
 661         SvSETMAGIC(output);
 662     }
 663     OUTPUT:
 664         RETVAL
 665
 666 uLong
 667 total_in_lo32(s)
 668         Compress::Raw::Bzip2   s
 669     CODE:
 670         RETVAL = s->stream.total_in_lo32 ;
 671     OUTPUT:
 672         RETVAL
 673
 674 uLong
 675 total_out_lo32(s)
 676         Compress::Raw::Bzip2   s
 677     CODE:
 678         RETVAL = s->stream.total_out_lo32 ;
 679     OUTPUT:
 680         RETVAL
 681
 682 uLong
 683 compressedBytes(s)
 684         Compress::Raw::Bzip2   s
 685     CODE:
 686         RETVAL = s->compressedBytes;
 687   OUTPUT:
 688         RETVAL
 689
 690 uLong
 691 uncompressedBytes(s)
 692         Compress::Raw::Bzip2   s
 693     CODE:
 694         RETVAL = s->uncompressedBytes;
 695   OUTPUT:
 696         RETVAL
 697
 698
 699 MODULE = Compress::Raw::Bunzip2 PACKAGE = Compress::Raw::Bunzip2
 700
 701 void
 702 DispStream(s, message=NULL)
 703     Compress::Raw::Bunzip2   s
 704     const char *  message
 705
 706 DualType
 707 bzinflate (s, buf, output)
 708     Compress::Raw::Bunzip2      s
 709     SV *        buf
 710     SV *        output
 711     uInt        cur_length = 0;
 712     uInt        prefix_length = 0;
 713     uInt        increment = 0;
 714     uInt    bufinc = NO_INIT
 715     STRLEN  na = NO_INIT ;
 716     STRLEN    origlen = NO_INIT
 717   PREINIT:
 718 #ifdef UTF8_AVAILABLE
 719     bool        out_utf8  = FALSE;
 720 #endif
 721   CODE:
 722     bufinc = s->bufsize;
 723     /* If the buffer is a reference, dereference it */
 724     buf = deRef(buf, "bzinflate") ;
 725
 726     if (s->flags & FLAG_CONSUME_INPUT) {
 727         if (SvREADONLY(buf))
 728             croak(UNCOMPRESS_CLASS "::bzinflate input parameter cannot be read-only when ConsumeInput is specified");
 729         SvPV_force(buf, na);
 730     }
 731 #ifdef UTF8_AVAILABLE
 732     if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
 733          croak("Wide character in " UNCOMPRESS_CLASS "::bzinflate input parameter");
 734 #endif
 735
 736     /* initialise the input buffer */
 737     s->stream.next_in = (char*)SvPV_nomg(buf, origlen) ;
 738     s->stream.avail_in = origlen;
 739
 740     /* and retrieve the output buffer */
 741     output = deRef_l(output, "bzinflate") ;
 742 #ifdef UTF8_AVAILABLE
 743     if (DO_UTF8(output))
 744          out_utf8 = TRUE ;
 745     if (DO_UTF8(output) && !sv_utf8_downgrade(output, 1))
 746          croak("Wide character in " UNCOMPRESS_CLASS "::bzinflate output parameter");
 747 #endif
 748     if((s->flags & FLAG_APPEND_OUTPUT) != FLAG_APPEND_OUTPUT) {
 749         SvCUR_set(output, 0);
 750     }
 751
 752     /* Assume no output buffer - the code below will update if there is any available */
 753     s->stream.avail_out = 0;
 754
 755     if (SvLEN(output)) {
 756         prefix_length = cur_length =  SvCUR(output) ;
 757
 758         if (s->flags & FLAG_LIMIT_OUTPUT && SvLEN(output) - cur_length - 1 < bufinc)
 759         {
 760             Sv_Grow(output, bufinc + cur_length + 1) ;
 761         }
 762
 763         /* Only setup the stream output pointers if there is spare
 764            capacity in the outout SV
 765         */
 766         if (SvLEN(output) > cur_length + 1)
 767         {
 768             s->stream.next_out = (char*) SvPVX(output) + cur_length;
 769             increment = SvLEN(output) -  cur_length - 1;
 770             s->stream.avail_out = increment;
 771         }
 772     }
 773
 774     s->bytesInflated = 0;
 775
 776     RETVAL = BZ_OK;
 777
 778     while (1) {
 779
 780         if (s->stream.avail_out == 0) {
 781             /* out of space in the output buffer so make it bigger */
 782             s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc + 1) ;
 783             cur_length += increment ;
 784             s->stream.next_out += cur_length ;
 785             increment = bufinc ;
 786             s->stream.avail_out = increment;
 787             bufinc *= 2 ;
 788         }
 789
 790         /* DispStream(s, "pre"); */
 791         RETVAL = BZ2_bzDecompress (&(s->stream));
 792
 793         /*
 794         printf("Status %d\n", RETVAL);
 795         DispStream(s, "apres");
 796         */
 797         if (RETVAL != BZ_OK || s->flags & FLAG_LIMIT_OUTPUT)
 798             break ;
 799
 800         if (s->stream.avail_out == 0)
 801             continue ;
 802
 803         if (s->stream.avail_in == 0) {
 804             RETVAL = BZ_OK ;
 805             break ;
 806         }
 807
 808     }
 809
 810     s->last_error = RETVAL ;
 811     if (RETVAL == BZ_OK || RETVAL == BZ_STREAM_END) {
 812         unsigned in ;
 813
 814         s->bytesInflated = cur_length + increment - s->stream.avail_out - prefix_length;
 815         s->uncompressedBytes += s->bytesInflated ;
 816         s->compressedBytes   += origlen - s->stream.avail_in  ;
 817
 818         SvPOK_only(output);
 819         SvCUR_set(output, prefix_length + s->bytesInflated) ;
 820         *SvEND(output) = '\0';
 821 #ifdef UTF8_AVAILABLE
 822         if (out_utf8)
 823             sv_utf8_upgrade(output);
 824 #endif
 825         SvSETMAGIC(output);
 826
 827         /* fix the input buffer */
 828         if (s->flags & FLAG_CONSUME_INPUT) {
 829             in = s->stream.avail_in ;
 830             SvCUR_set(buf, in) ;
 831             if (in)
 832                 Move(s->stream.next_in, SvPVX(buf), in, char) ;
 833             *SvEND(buf) = '\0';
 834             SvSETMAGIC(buf);
 835         }
 836     }
 837     OUTPUT:
 838         RETVAL
 839
 840 uLong
 841 inflateCount(s)
 842     Compress::Raw::Bunzip2      s
 843     CODE:
 844         RETVAL = s->bytesInflated;
 845   OUTPUT:
 846         RETVAL
 847
 848
 849 void
 850 DESTROY(s)
 851     Compress::Raw::Bunzip2      s
 852   CODE:
 853     BZ2_bzDecompressEnd(&s->stream) ;
 854     Safefree(s) ;
 855
 856
 857 uLong
 858 status(s)
 859         Compress::Raw::Bunzip2   s
 860     CODE:
 861         RETVAL = s->last_error ;
 862     OUTPUT:
 863         RETVAL
 864
 865 uLong
 866 total_in_lo32(s)
 867         Compress::Raw::Bunzip2   s
 868     CODE:
 869         RETVAL = s->stream.total_in_lo32 ;
 870     OUTPUT:
 871         RETVAL
 872
 873 uLong
 874 total_out_lo32(s)
 875         Compress::Raw::Bunzip2   s
 876     CODE:
 877         RETVAL = s->stream.total_out_lo32 ;
 878     OUTPUT:
 879         RETVAL
 880
 881 uLong
 882 compressedBytes(s)
 883         Compress::Raw::Bunzip2   s
 884     CODE:
 885         RETVAL = s->compressedBytes;
 886   OUTPUT:
 887         RETVAL
 888
 889 uLong
 890 uncompressedBytes(s)
 891         Compress::Raw::Bunzip2   s
 892     CODE:
 893         RETVAL = s->uncompressedBytes;
 894   OUTPUT:
 895         RETVAL
 896
 897 MODULE = Compress::Raw::Bzip2 PACKAGE = Compress::Raw::Bzip2        PREFIX = Zip_