This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Update Compress-Raw-Zlib to CPAN version 2.033
[perl5.git] / cpan / Compress-Raw-Zlib / lib / Compress / Raw / Zlib.pm
1
2 package Compress::Raw::Zlib;
3
4 require 5.004 ;
5 require Exporter;
6 use AutoLoader;
7 use Carp ;
8
9 #use Parse::Parameters;
10
11 use strict ;
12 use warnings ;
13 use bytes ;
14 our ($VERSION, $XS_VERSION, @ISA, @EXPORT, $AUTOLOAD);
15
16 $VERSION = '2.033';
17 $XS_VERSION = $VERSION; 
18 $VERSION = eval $VERSION;
19
20 @ISA = qw(Exporter);
21 # Items to export into callers namespace by default. Note: do not export
22 # names by default without a very good reason. Use EXPORT_OK instead.
23 # Do not simply export all your public functions/methods/constants.
24 @EXPORT = qw(
25         adler32 crc32
26
27         ZLIB_VERSION
28         ZLIB_VERNUM
29
30         DEF_WBITS
31         OS_CODE
32
33         MAX_MEM_LEVEL
34         MAX_WBITS
35
36         Z_ASCII
37         Z_BEST_COMPRESSION
38         Z_BEST_SPEED
39         Z_BINARY
40         Z_BLOCK
41         Z_BUF_ERROR
42         Z_DATA_ERROR
43         Z_DEFAULT_COMPRESSION
44         Z_DEFAULT_STRATEGY
45         Z_DEFLATED
46         Z_ERRNO
47         Z_FILTERED
48         Z_FIXED
49         Z_FINISH
50         Z_FULL_FLUSH
51         Z_HUFFMAN_ONLY
52         Z_MEM_ERROR
53         Z_NEED_DICT
54         Z_NO_COMPRESSION
55         Z_NO_FLUSH
56         Z_NULL
57         Z_OK
58         Z_PARTIAL_FLUSH
59         Z_RLE
60         Z_STREAM_END
61         Z_STREAM_ERROR
62         Z_SYNC_FLUSH
63         Z_TREES
64         Z_UNKNOWN
65         Z_VERSION_ERROR
66
67         WANT_GZIP
68         WANT_GZIP_OR_ZLIB
69 );
70
71 use constant WANT_GZIP           => 16;
72 use constant WANT_GZIP_OR_ZLIB   => 32;
73
74 sub AUTOLOAD {
75     my($constname);
76     ($constname = $AUTOLOAD) =~ s/.*:://;
77     my ($error, $val) = constant($constname);
78     Carp::croak $error if $error;
79     no strict 'refs';
80     *{$AUTOLOAD} = sub { $val };
81     goto &{$AUTOLOAD};
82 }
83
84 use constant FLAG_APPEND             => 1 ;
85 use constant FLAG_CRC                => 2 ;
86 use constant FLAG_ADLER              => 4 ;
87 use constant FLAG_CONSUME_INPUT      => 8 ;
88 use constant FLAG_LIMIT_OUTPUT       => 16 ;
89
90 eval {
91     require XSLoader;
92     XSLoader::load('Compress::Raw::Zlib', $XS_VERSION);
93     1;
94
95 or do {
96     require DynaLoader;
97     local @ISA = qw(DynaLoader);
98     bootstrap Compress::Raw::Zlib $XS_VERSION ; 
99 };
100  
101
102 use constant Parse_any      => 0x01;
103 use constant Parse_unsigned => 0x02;
104 use constant Parse_signed   => 0x04;
105 use constant Parse_boolean  => 0x08;
106 use constant Parse_string   => 0x10;
107 use constant Parse_custom   => 0x12;
108
109 use constant Parse_store_ref => 0x100 ;
110
111 use constant OFF_PARSED     => 0 ;
112 use constant OFF_TYPE       => 1 ;
113 use constant OFF_DEFAULT    => 2 ;
114 use constant OFF_FIXED      => 3 ;
115 use constant OFF_FIRST_ONLY => 4 ;
116 use constant OFF_STICKY     => 5 ;
117
118
119
120 sub ParseParameters
121 {
122     my $level = shift || 0 ; 
123
124     my $sub = (caller($level + 1))[3] ;
125     #local $Carp::CarpLevel = 1 ;
126     my $p = new Compress::Raw::Zlib::Parameters() ;
127     $p->parse(@_)
128         or croak "$sub: $p->{Error}" ;
129
130     return $p;
131 }
132
133
134 sub Compress::Raw::Zlib::Parameters::new
135 {
136     my $class = shift ;
137
138     my $obj = { Error => '',
139                 Got   => {},
140               } ;
141
142     #return bless $obj, ref($class) || $class || __PACKAGE__ ;
143     return bless $obj, 'Compress::Raw::Zlib::Parameters' ;
144 }
145
146 sub Compress::Raw::Zlib::Parameters::setError
147 {
148     my $self = shift ;
149     my $error = shift ;
150     my $retval = @_ ? shift : undef ;
151
152     $self->{Error} = $error ;
153     return $retval;
154 }
155           
156 #sub getError
157 #{
158 #    my $self = shift ;
159 #    return $self->{Error} ;
160 #}
161           
162 sub Compress::Raw::Zlib::Parameters::parse
163 {
164     my $self = shift ;
165
166     my $default = shift ;
167
168     my $got = $self->{Got} ;
169     my $firstTime = keys %{ $got } == 0 ;
170
171     my (@Bad) ;
172     my @entered = () ;
173
174     # Allow the options to be passed as a hash reference or
175     # as the complete hash.
176     if (@_ == 0) {
177         @entered = () ;
178     }
179     elsif (@_ == 1) {
180         my $href = $_[0] ;    
181         return $self->setError("Expected even number of parameters, got 1")
182             if ! defined $href or ! ref $href or ref $href ne "HASH" ;
183  
184         foreach my $key (keys %$href) {
185             push @entered, $key ;
186             push @entered, \$href->{$key} ;
187         }
188     }
189     else {
190         my $count = @_;
191         return $self->setError("Expected even number of parameters, got $count")
192             if $count % 2 != 0 ;
193         
194         for my $i (0.. $count / 2 - 1) {
195             push @entered, $_[2* $i] ;
196             push @entered, \$_[2* $i+1] ;
197         }
198     }
199
200
201     while (my ($key, $v) = each %$default)
202     {
203         croak "need 4 params [@$v]"
204             if @$v != 4 ;
205
206         my ($first_only, $sticky, $type, $value) = @$v ;
207         my $x ;
208         $self->_checkType($key, \$value, $type, 0, \$x) 
209             or return undef ;
210
211         $key = lc $key;
212
213         if ($firstTime || ! $sticky) {
214             $got->{$key} = [0, $type, $value, $x, $first_only, $sticky] ;
215         }
216
217         $got->{$key}[OFF_PARSED] = 0 ;
218     }
219
220     for my $i (0.. @entered / 2 - 1) {
221         my $key = $entered[2* $i] ;
222         my $value = $entered[2* $i+1] ;
223
224         #print "Key [$key] Value [$value]" ;
225         #print defined $$value ? "[$$value]\n" : "[undef]\n";
226
227         $key =~ s/^-// ;
228         my $canonkey = lc $key;
229  
230         if ($got->{$canonkey} && ($firstTime ||
231                                   ! $got->{$canonkey}[OFF_FIRST_ONLY]  ))
232         {
233             my $type = $got->{$canonkey}[OFF_TYPE] ;
234             my $s ;
235             $self->_checkType($key, $value, $type, 1, \$s)
236                 or return undef ;
237             #$value = $$value unless $type & Parse_store_ref ;
238             $value = $$value ;
239             $got->{$canonkey} = [1, $type, $value, $s] ;
240         }
241         else
242           { push (@Bad, $key) }
243     }
244  
245     if (@Bad) {
246         my ($bad) = join(", ", @Bad) ;
247         return $self->setError("unknown key value(s) @Bad") ;
248     }
249
250     return 1;
251 }
252
253 sub Compress::Raw::Zlib::Parameters::_checkType
254 {
255     my $self = shift ;
256
257     my $key   = shift ;
258     my $value = shift ;
259     my $type  = shift ;
260     my $validate  = shift ;
261     my $output  = shift;
262
263     #local $Carp::CarpLevel = $level ;
264     #print "PARSE $type $key $value $validate $sub\n" ;
265     if ( $type & Parse_store_ref)
266     {
267         #$value = $$value
268         #    if ref ${ $value } ;
269
270         $$output = $value ;
271         return 1;
272     }
273
274     $value = $$value ;
275
276     if ($type & Parse_any)
277     {
278         $$output = $value ;
279         return 1;
280     }
281     elsif ($type & Parse_unsigned)
282     {
283         return $self->setError("Parameter '$key' must be an unsigned int, got 'undef'")
284             if $validate && ! defined $value ;
285         return $self->setError("Parameter '$key' must be an unsigned int, got '$value'")
286             if $validate && $value !~ /^\d+$/;
287
288         $$output = defined $value ? $value : 0 ;    
289         return 1;
290     }
291     elsif ($type & Parse_signed)
292     {
293         return $self->setError("Parameter '$key' must be a signed int, got 'undef'")
294             if $validate && ! defined $value ;
295         return $self->setError("Parameter '$key' must be a signed int, got '$value'")
296             if $validate && $value !~ /^-?\d+$/;
297
298         $$output = defined $value ? $value : 0 ;    
299         return 1 ;
300     }
301     elsif ($type & Parse_boolean)
302     {
303         return $self->setError("Parameter '$key' must be an int, got '$value'")
304             if $validate && defined $value && $value !~ /^\d*$/;
305         $$output =  defined $value ? $value != 0 : 0 ;    
306         return 1;
307     }
308     elsif ($type & Parse_string)
309     {
310         $$output = defined $value ? $value : "" ;    
311         return 1;
312     }
313
314     $$output = $value ;
315     return 1;
316 }
317
318
319
320 sub Compress::Raw::Zlib::Parameters::parsed
321 {
322     my $self = shift ;
323     my $name = shift ;
324
325     return $self->{Got}{lc $name}[OFF_PARSED] ;
326 }
327
328 sub Compress::Raw::Zlib::Parameters::value
329 {
330     my $self = shift ;
331     my $name = shift ;
332
333     if (@_)
334     {
335         $self->{Got}{lc $name}[OFF_PARSED]  = 1;
336         $self->{Got}{lc $name}[OFF_DEFAULT] = $_[0] ;
337         $self->{Got}{lc $name}[OFF_FIXED]   = $_[0] ;
338     }
339
340     return $self->{Got}{lc $name}[OFF_FIXED] ;
341 }
342
343 sub Compress::Raw::Zlib::Deflate::new
344 {
345     my $pkg = shift ;
346     my ($got) = ParseParameters(0,
347             {
348                 'AppendOutput'  => [1, 1, Parse_boolean,  0],
349                 'CRC32'         => [1, 1, Parse_boolean,  0],
350                 'ADLER32'       => [1, 1, Parse_boolean,  0],
351                 'Bufsize'       => [1, 1, Parse_unsigned, 4096],
352  
353                 'Level'         => [1, 1, Parse_signed,   Z_DEFAULT_COMPRESSION()],
354                 'Method'        => [1, 1, Parse_unsigned, Z_DEFLATED()],
355                 'WindowBits'    => [1, 1, Parse_signed,   MAX_WBITS()],
356                 'MemLevel'      => [1, 1, Parse_unsigned, MAX_MEM_LEVEL()],
357                 'Strategy'      => [1, 1, Parse_unsigned, Z_DEFAULT_STRATEGY()],
358                 'Dictionary'    => [1, 1, Parse_any,      ""],
359             }, @_) ;
360
361
362     croak "Compress::Raw::Zlib::Deflate::new: Bufsize must be >= 1, you specified " . 
363             $got->value('Bufsize')
364         unless $got->value('Bufsize') >= 1;
365
366     my $flags = 0 ;
367     $flags |= FLAG_APPEND if $got->value('AppendOutput') ;
368     $flags |= FLAG_CRC    if $got->value('CRC32') ;
369     $flags |= FLAG_ADLER  if $got->value('ADLER32') ;
370
371     my $windowBits =  $got->value('WindowBits');
372     $windowBits += MAX_WBITS()
373         if ($windowBits & MAX_WBITS()) == 0 ;
374
375     _deflateInit($flags,
376                 $got->value('Level'), 
377                 $got->value('Method'), 
378                 $windowBits, 
379                 $got->value('MemLevel'), 
380                 $got->value('Strategy'), 
381                 $got->value('Bufsize'),
382                 $got->value('Dictionary')) ;
383
384 }
385
386 sub Compress::Raw::Zlib::Inflate::new
387 {
388     my $pkg = shift ;
389     my ($got) = ParseParameters(0,
390                     {
391                         'AppendOutput'  => [1, 1, Parse_boolean,  0],
392                         'LimitOutput'   => [1, 1, Parse_boolean,  0],
393                         'CRC32'         => [1, 1, Parse_boolean,  0],
394                         'ADLER32'       => [1, 1, Parse_boolean,  0],
395                         'ConsumeInput'  => [1, 1, Parse_boolean,  1],
396                         'Bufsize'       => [1, 1, Parse_unsigned, 4096],
397                  
398                         'WindowBits'    => [1, 1, Parse_signed,   MAX_WBITS()],
399                         'Dictionary'    => [1, 1, Parse_any,      ""],
400             }, @_) ;
401
402
403     croak "Compress::Raw::Zlib::Inflate::new: Bufsize must be >= 1, you specified " . 
404             $got->value('Bufsize')
405         unless $got->value('Bufsize') >= 1;
406
407     my $flags = 0 ;
408     $flags |= FLAG_APPEND if $got->value('AppendOutput') ;
409     $flags |= FLAG_CRC    if $got->value('CRC32') ;
410     $flags |= FLAG_ADLER  if $got->value('ADLER32') ;
411     $flags |= FLAG_CONSUME_INPUT if $got->value('ConsumeInput') ;
412     $flags |= FLAG_LIMIT_OUTPUT if $got->value('LimitOutput') ;
413
414
415     my $windowBits =  $got->value('WindowBits');
416     $windowBits += MAX_WBITS()
417         if ($windowBits & MAX_WBITS()) == 0 ;
418
419     _inflateInit($flags, $windowBits, $got->value('Bufsize'), 
420                  $got->value('Dictionary')) ;
421 }
422
423 sub Compress::Raw::Zlib::InflateScan::new
424 {
425     my $pkg = shift ;
426     my ($got) = ParseParameters(0,
427                     {
428                         'CRC32'         => [1, 1, Parse_boolean,  0],
429                         'ADLER32'       => [1, 1, Parse_boolean,  0],
430                         'Bufsize'       => [1, 1, Parse_unsigned, 4096],
431                  
432                         'WindowBits'    => [1, 1, Parse_signed,   -MAX_WBITS()],
433                         'Dictionary'    => [1, 1, Parse_any,      ""],
434             }, @_) ;
435
436
437     croak "Compress::Raw::Zlib::InflateScan::new: Bufsize must be >= 1, you specified " . 
438             $got->value('Bufsize')
439         unless $got->value('Bufsize') >= 1;
440
441     my $flags = 0 ;
442     #$flags |= FLAG_APPEND if $got->value('AppendOutput') ;
443     $flags |= FLAG_CRC    if $got->value('CRC32') ;
444     $flags |= FLAG_ADLER  if $got->value('ADLER32') ;
445     #$flags |= FLAG_CONSUME_INPUT if $got->value('ConsumeInput') ;
446
447     _inflateScanInit($flags, $got->value('WindowBits'), $got->value('Bufsize'), 
448                  '') ;
449 }
450
451 sub Compress::Raw::Zlib::inflateScanStream::createDeflateStream
452 {
453     my $pkg = shift ;
454     my ($got) = ParseParameters(0,
455             {
456                 'AppendOutput'  => [1, 1, Parse_boolean,  0],
457                 'CRC32'         => [1, 1, Parse_boolean,  0],
458                 'ADLER32'       => [1, 1, Parse_boolean,  0],
459                 'Bufsize'       => [1, 1, Parse_unsigned, 4096],
460  
461                 'Level'         => [1, 1, Parse_signed,   Z_DEFAULT_COMPRESSION()],
462                 'Method'        => [1, 1, Parse_unsigned, Z_DEFLATED()],
463                 'WindowBits'    => [1, 1, Parse_signed,   - MAX_WBITS()],
464                 'MemLevel'      => [1, 1, Parse_unsigned, MAX_MEM_LEVEL()],
465                 'Strategy'      => [1, 1, Parse_unsigned, Z_DEFAULT_STRATEGY()],
466             }, @_) ;
467
468     croak "Compress::Raw::Zlib::InflateScan::createDeflateStream: Bufsize must be >= 1, you specified " . 
469             $got->value('Bufsize')
470         unless $got->value('Bufsize') >= 1;
471
472     my $flags = 0 ;
473     $flags |= FLAG_APPEND if $got->value('AppendOutput') ;
474     $flags |= FLAG_CRC    if $got->value('CRC32') ;
475     $flags |= FLAG_ADLER  if $got->value('ADLER32') ;
476
477     $pkg->_createDeflateStream($flags,
478                 $got->value('Level'), 
479                 $got->value('Method'), 
480                 $got->value('WindowBits'), 
481                 $got->value('MemLevel'), 
482                 $got->value('Strategy'), 
483                 $got->value('Bufsize'),
484                 ) ;
485
486 }
487
488 sub Compress::Raw::Zlib::inflateScanStream::inflate
489 {
490     my $self = shift ;
491     my $buffer = $_[1];
492     my $eof = $_[2];
493
494     my $status = $self->scan(@_);
495
496     if ($status == Z_OK() && $_[2]) {
497         my $byte = ' ';
498         
499         $status = $self->scan(\$byte, $_[1]) ;
500     }
501     
502     return $status ;
503 }
504
505 sub Compress::Raw::Zlib::deflateStream::deflateParams
506 {
507     my $self = shift ;
508     my ($got) = ParseParameters(0, {
509                 'Level'      => [1, 1, Parse_signed,   undef],
510                 'Strategy'   => [1, 1, Parse_unsigned, undef],
511                 'Bufsize'    => [1, 1, Parse_unsigned, undef],
512                 }, 
513                 @_) ;
514
515     croak "Compress::Raw::Zlib::deflateParams needs Level and/or Strategy"
516         unless $got->parsed('Level') + $got->parsed('Strategy') +
517             $got->parsed('Bufsize');
518
519     croak "Compress::Raw::Zlib::Inflate::deflateParams: Bufsize must be >= 1, you specified " . 
520             $got->value('Bufsize')
521         if $got->parsed('Bufsize') && $got->value('Bufsize') <= 1;
522
523     my $flags = 0;
524     $flags |= 1 if $got->parsed('Level') ;
525     $flags |= 2 if $got->parsed('Strategy') ;
526     $flags |= 4 if $got->parsed('Bufsize') ;
527
528     $self->_deflateParams($flags, $got->value('Level'), 
529                           $got->value('Strategy'), $got->value('Bufsize'));
530
531 }
532
533
534 # Autoload methods go after __END__, and are processed by the autosplit program.
535
536 1;
537 __END__
538
539
540 =head1 NAME
541
542 Compress::Raw::Zlib - Low-Level Interface to zlib compression library
543
544 =head1 SYNOPSIS
545
546     use Compress::Raw::Zlib ;
547
548     ($d, $status) = new Compress::Raw::Zlib::Deflate( [OPT] ) ;
549     $status = $d->deflate($input, $output) ;
550     $status = $d->flush($output [, $flush_type]) ;
551     $d->deflateReset() ;
552     $d->deflateParams(OPTS) ;
553     $d->deflateTune(OPTS) ;
554     $d->dict_adler() ;
555     $d->crc32() ;
556     $d->adler32() ;
557     $d->total_in() ;
558     $d->total_out() ;
559     $d->msg() ;
560     $d->get_Strategy();
561     $d->get_Level();
562     $d->get_BufSize();
563
564     ($i, $status) = new Compress::Raw::Zlib::Inflate( [OPT] ) ;
565     $status = $i->inflate($input, $output [, $eof]) ;
566     $status = $i->inflateSync($input) ;
567     $i->inflateReset() ;
568     $i->dict_adler() ;
569     $d->crc32() ;
570     $d->adler32() ;
571     $i->total_in() ;
572     $i->total_out() ;
573     $i->msg() ;
574     $d->get_BufSize();
575
576     $crc = adler32($buffer [,$crc]) ;
577     $crc = crc32($buffer [,$crc]) ;
578
579     $crc = adler32_combine($crc1, $crc2, $len2)l
580     $crc = crc32_combine($adler1, $adler2, $len2)
581
582     my $version = Compress::Raw::Zlib::zlib_version();
583
584 =head1 DESCRIPTION
585
586 The I<Compress::Raw::Zlib> module provides a Perl interface to the I<zlib>
587 compression library (see L</AUTHOR> for details about where to get
588 I<zlib>). 
589
590 =head1 Compress::Raw::Zlib::Deflate
591
592 This section defines an interface that allows in-memory compression using
593 the I<deflate> interface provided by zlib.
594
595 Here is a definition of the interface available:
596
597 =head2 B<($d, $status) = new Compress::Raw::Zlib::Deflate( [OPT] ) >
598
599 Initialises a deflation object. 
600
601 If you are familiar with the I<zlib> library, it combines the
602 features of the I<zlib> functions C<deflateInit>, C<deflateInit2>
603 and C<deflateSetDictionary>.
604
605 If successful, it will return the initialised deflation object, C<$d>
606 and a C<$status> of C<Z_OK> in a list context. In scalar context it
607 returns the deflation object, C<$d>, only.
608
609 If not successful, the returned deflation object, C<$d>, will be
610 I<undef> and C<$status> will hold the a I<zlib> error code.
611
612 The function optionally takes a number of named options specified as
613 C<< Name => value >> pairs. This allows individual options to be
614 tailored without having to specify them all in the parameter list.
615
616 For backward compatibility, it is also possible to pass the parameters
617 as a reference to a hash containing the name=>value pairs.
618
619 Below is a list of the valid options:
620
621 =over 5
622
623 =item B<-Level>
624
625 Defines the compression level. Valid values are 0 through 9,
626 C<Z_NO_COMPRESSION>, C<Z_BEST_SPEED>, C<Z_BEST_COMPRESSION>, and
627 C<Z_DEFAULT_COMPRESSION>.
628
629 The default is C<Z_DEFAULT_COMPRESSION>.
630
631 =item B<-Method>
632
633 Defines the compression method. The only valid value at present (and
634 the default) is C<Z_DEFLATED>.
635
636 =item B<-WindowBits>
637
638 To compress an RFC 1950 data stream, set C<WindowBits> to a positive
639 number between 8 and 15.
640
641 To compress an RFC 1951 data stream, set C<WindowBits> to C<-MAX_WBITS>.
642
643 To compress an RFC 1952 data stream (i.e. gzip), set C<WindowBits> to
644 C<WANT_GZIP>.
645
646 For a definition of the meaning and valid values for C<WindowBits>
647 refer to the I<zlib> documentation for I<deflateInit2>.
648
649 Defaults to C<MAX_WBITS>.
650
651 =item B<-MemLevel>
652
653 For a definition of the meaning and valid values for C<MemLevel>
654 refer to the I<zlib> documentation for I<deflateInit2>.
655
656 Defaults to MAX_MEM_LEVEL.
657
658 =item B<-Strategy>
659
660 Defines the strategy used to tune the compression. The valid values are
661 C<Z_DEFAULT_STRATEGY>, C<Z_FILTERED>, C<Z_RLE>, C<Z_FIXED> and
662 C<Z_HUFFMAN_ONLY>.
663
664 The default is C<Z_DEFAULT_STRATEGY>.
665
666 =item B<-Dictionary>
667
668 When a dictionary is specified I<Compress::Raw::Zlib> will automatically
669 call C<deflateSetDictionary> directly after calling C<deflateInit>. The
670 Adler32 value for the dictionary can be obtained by calling the method 
671 C<$d-E<gt>dict_adler()>.
672
673 The default is no dictionary.
674
675 =item B<-Bufsize>
676
677 Sets the initial size for the output buffer used by the C<$d-E<gt>deflate>
678 and C<$d-E<gt>flush> methods. If the buffer has to be
679 reallocated to increase the size, it will grow in increments of
680 C<Bufsize>.
681
682 The default buffer size is 4096.
683
684 =item B<-AppendOutput>
685
686 This option controls how data is written to the output buffer by the
687 C<$d-E<gt>deflate> and C<$d-E<gt>flush> methods.
688
689 If the C<AppendOutput> option is set to false, the output buffers in the
690 C<$d-E<gt>deflate> and C<$d-E<gt>flush>  methods will be truncated before
691 uncompressed data is written to them.
692
693 If the option is set to true, uncompressed data will be appended to the
694 output buffer in the C<$d-E<gt>deflate> and C<$d-E<gt>flush> methods.
695
696 This option defaults to false.
697
698 =item B<-CRC32>
699
700 If set to true, a crc32 checksum of the uncompressed data will be
701 calculated. Use the C<$d-E<gt>crc32> method to retrieve this value.
702
703 This option defaults to false.
704
705 =item B<-ADLER32>
706
707 If set to true, an adler32 checksum of the uncompressed data will be
708 calculated. Use the C<$d-E<gt>adler32> method to retrieve this value.
709
710 This option defaults to false.
711
712 =back
713
714 Here is an example of using the C<Compress::Raw::Zlib::Deflate> optional
715 parameter list to override the default buffer size and compression
716 level. All other options will take their default values.
717
718     my $d = new Compress::Raw::Zlib::Deflate ( -Bufsize => 300, 
719                                                -Level   => Z_BEST_SPEED ) ;
720
721 =head2 B<$status = $d-E<gt>deflate($input, $output)>
722
723 Deflates the contents of C<$input> and writes the compressed data to
724 C<$output>.
725
726 The C<$input> and C<$output> parameters can be either scalars or scalar
727 references.
728
729 When finished, C<$input> will be completely processed (assuming there
730 were no errors). If the deflation was successful it writes the deflated
731 data to C<$output> and returns a status value of C<Z_OK>.
732
733 On error, it returns a I<zlib> error code.
734
735 If the C<AppendOutput> option is set to true in the constructor for
736 the C<$d> object, the compressed data will be appended to C<$output>. If
737 it is false, C<$output> will be truncated before any compressed data is
738 written to it.
739
740 B<Note>: This method will not necessarily write compressed data to
741 C<$output> every time it is called. So do not assume that there has been
742 an error if the contents of C<$output> is empty on returning from
743 this method. As long as the return code from the method is C<Z_OK>,
744 the deflate has succeeded.
745
746 =head2 B<$status = $d-E<gt>flush($output [, $flush_type]) >
747
748 Typically used to finish the deflation. Any pending output will be
749 written to C<$output>.
750
751 Returns C<Z_OK> if successful.
752
753 Note that flushing can seriously degrade the compression ratio, so it
754 should only be used to terminate a decompression (using C<Z_FINISH>) or
755 when you want to create a I<full flush point> (using C<Z_FULL_FLUSH>).
756
757 By default the C<flush_type> used is C<Z_FINISH>. Other valid values
758 for C<flush_type> are C<Z_NO_FLUSH>, C<Z_PARTIAL_FLUSH>, C<Z_SYNC_FLUSH>
759 and C<Z_FULL_FLUSH>. It is strongly recommended that you only set the
760 C<flush_type> parameter if you fully understand the implications of
761 what it does. See the C<zlib> documentation for details.
762
763 If the C<AppendOutput> option is set to true in the constructor for
764 the C<$d> object, the compressed data will be appended to C<$output>. If
765 it is false, C<$output> will be truncated before any compressed data is
766 written to it.
767
768 =head2 B<$status = $d-E<gt>deflateReset() >
769
770 This method will reset the deflation object C<$d>. It can be used when you
771 are compressing multiple data streams and want to use the same object to
772 compress each of them. It should only be used once the previous data stream
773 has been flushed successfully, i.e. a call to C<< $d->flush(Z_FINISH) >> has
774 returned C<Z_OK>.
775
776 Returns C<Z_OK> if successful.
777
778 =head2 B<$status = $d-E<gt>deflateParams([OPT])>
779
780 Change settings for the deflate object C<$d>.
781
782 The list of the valid options is shown below. Options not specified
783 will remain unchanged.
784
785 =over 5
786
787 =item B<-Level>
788
789 Defines the compression level. Valid values are 0 through 9,
790 C<Z_NO_COMPRESSION>, C<Z_BEST_SPEED>, C<Z_BEST_COMPRESSION>, and
791 C<Z_DEFAULT_COMPRESSION>.
792
793 =item B<-Strategy>
794
795 Defines the strategy used to tune the compression. The valid values are
796 C<Z_DEFAULT_STRATEGY>, C<Z_FILTERED> and C<Z_HUFFMAN_ONLY>. 
797
798 =item B<-BufSize>
799
800 Sets the initial size for the output buffer used by the C<$d-E<gt>deflate>
801 and C<$d-E<gt>flush> methods. If the buffer has to be
802 reallocated to increase the size, it will grow in increments of
803 C<Bufsize>.
804
805 =back
806
807 =head2 B<$status = $d-E<gt>deflateTune($good_length, $max_lazy, $nice_length, $max_chain)>
808
809 Tune the internal settings for the deflate object C<$d>. This option is
810 only available if you are running zlib 1.2.2.3 or better.
811
812 Refer to the documentation in zlib.h for instructions on how to fly
813 C<deflateTune>.
814
815 =head2 B<$d-E<gt>dict_adler()>
816
817 Returns the adler32 value for the dictionary.
818
819 =head2 B<$d-E<gt>crc32()>
820
821 Returns the crc32 value for the uncompressed data to date. 
822
823 If the C<CRC32> option is not enabled in the constructor for this object,
824 this method will always return 0;
825
826 =head2 B<$d-E<gt>adler32()>
827
828 Returns the adler32 value for the uncompressed data to date. 
829
830 =head2 B<$d-E<gt>msg()>
831
832 Returns the last error message generated by zlib.
833
834 =head2 B<$d-E<gt>total_in()>
835
836 Returns the total number of bytes uncompressed bytes input to deflate.
837
838 =head2 B<$d-E<gt>total_out()>
839
840 Returns the total number of compressed bytes output from deflate.
841
842 =head2 B<$d-E<gt>get_Strategy()>
843
844 Returns the deflation strategy currently used. Valid values are
845 C<Z_DEFAULT_STRATEGY>, C<Z_FILTERED> and C<Z_HUFFMAN_ONLY>. 
846
847 =head2 B<$d-E<gt>get_Level()>
848
849 Returns the compression level being used. 
850
851 =head2 B<$d-E<gt>get_BufSize()>
852
853 Returns the buffer size used to carry out the compression.
854
855 =head2 Example
856
857 Here is a trivial example of using C<deflate>. It simply reads standard
858 input, deflates it and writes it to standard output.
859
860     use strict ;
861     use warnings ;
862
863     use Compress::Raw::Zlib ;
864
865     binmode STDIN;
866     binmode STDOUT;
867     my $x = new Compress::Raw::Zlib::Deflate
868        or die "Cannot create a deflation stream\n" ;
869
870     my ($output, $status) ;
871     while (<>)
872     {
873         $status = $x->deflate($_, $output) ;
874     
875         $status == Z_OK
876             or die "deflation failed\n" ;
877     
878         print $output ;
879     }
880     
881     $status = $x->flush($output) ;
882     
883     $status == Z_OK
884         or die "deflation failed\n" ;
885     
886     print $output ;
887
888 =head1 Compress::Raw::Zlib::Inflate
889
890 This section defines an interface that allows in-memory uncompression using
891 the I<inflate> interface provided by zlib.
892
893 Here is a definition of the interface:
894
895 =head2 B< ($i, $status) = new Compress::Raw::Zlib::Inflate( [OPT] ) >
896
897 Initialises an inflation object. 
898
899 In a list context it returns the inflation object, C<$i>, and the
900 I<zlib> status code (C<$status>). In a scalar context it returns the
901 inflation object only.
902
903 If successful, C<$i> will hold the inflation object and C<$status> will
904 be C<Z_OK>.
905
906 If not successful, C<$i> will be I<undef> and C<$status> will hold the
907 I<zlib> error code.
908
909 The function optionally takes a number of named options specified as
910 C<< -Name => value >> pairs. This allows individual options to be
911 tailored without having to specify them all in the parameter list.
912
913 For backward compatibility, it is also possible to pass the parameters
914 as a reference to a hash containing the C<< name=>value >> pairs.
915
916 Here is a list of the valid options:
917
918 =over 5
919
920 =item B<-WindowBits>
921
922 To uncompress an RFC 1950 data stream, set C<WindowBits> to a positive
923 number between 8 and 15.
924
925 To uncompress an RFC 1951 data stream, set C<WindowBits> to C<-MAX_WBITS>.
926
927 To uncompress an RFC 1952 data stream (i.e. gzip), set C<WindowBits> to
928 C<WANT_GZIP>.
929
930 To auto-detect and uncompress an RFC 1950 or RFC 1952 data stream (i.e.
931 gzip), set C<WindowBits> to C<WANT_GZIP_OR_ZLIB>.
932
933 For a full definition of the meaning and valid values for C<WindowBits>
934 refer to the I<zlib> documentation for I<inflateInit2>.
935
936 Defaults to C<MAX_WBITS>.
937
938 =item B<-Bufsize>
939
940 Sets the initial size for the output buffer used by the C<$i-E<gt>inflate>
941 method. If the output buffer in this method has to be reallocated to
942 increase the size, it will grow in increments of C<Bufsize>.
943
944 Default is 4096.
945
946 =item B<-Dictionary>
947
948 The default is no dictionary.
949
950 =item B<-AppendOutput>
951
952 This option controls how data is written to the output buffer by the
953 C<$i-E<gt>inflate> method.
954
955 If the option is set to false, the output buffer in the C<$i-E<gt>inflate>
956 method will be truncated before uncompressed data is written to it.
957
958 If the option is set to true, uncompressed data will be appended to the
959 output buffer by the C<$i-E<gt>inflate> method.
960
961 This option defaults to false.
962
963 =item B<-CRC32>
964
965 If set to true, a crc32 checksum of the uncompressed data will be
966 calculated. Use the C<$i-E<gt>crc32> method to retrieve this value.
967
968 This option defaults to false.
969
970 =item B<-ADLER32>
971
972 If set to true, an adler32 checksum of the uncompressed data will be
973 calculated. Use the C<$i-E<gt>adler32> method to retrieve this value.
974
975 This option defaults to false.
976
977 =item B<-ConsumeInput>
978
979 If set to true, this option will remove compressed data from the input
980 buffer of the C<< $i->inflate >> method as the inflate progresses.
981
982 This option can be useful when you are processing compressed data that is
983 embedded in another file/buffer. In this case the data that immediately
984 follows the compressed stream will be left in the input buffer.
985
986 This option defaults to true.
987
988 =item B<-LimitOutput>
989
990 The C<LimitOutput> option changes the behavior of the C<< $i->inflate >>
991 method so that the amount of memory used by the output buffer can be
992 limited. 
993
994 When C<LimitOutput> is used the size of the output buffer used will either
995 be the value of the C<Bufsize> option or the amount of memory already
996 allocated to C<$output>, whichever is larger. Predicting the output size
997 available is tricky, so don't rely on getting an exact output buffer size.
998
999 When C<LimitOutout> is not specified C<< $i->inflate >> will use as much
1000 memory as it takes to write all the uncompressed data it creates by
1001 uncompressing the input buffer.
1002
1003 If C<LimitOutput> is enabled, the C<ConsumeInput> option will also be
1004 enabled.
1005
1006 This option defaults to false.
1007
1008 See L</The LimitOutput option> for a discussion on why C<LimitOutput> is
1009 needed and how to use it.
1010
1011 =back
1012
1013 Here is an example of using an optional parameter to override the default
1014 buffer size.
1015
1016     my ($i, $status) = new Compress::Raw::Zlib::Inflate( -Bufsize => 300 ) ;
1017
1018 =head2 B< $status = $i-E<gt>inflate($input, $output [,$eof]) >
1019
1020 Inflates the complete contents of C<$input> and writes the uncompressed
1021 data to C<$output>. The C<$input> and C<$output> parameters can either be
1022 scalars or scalar references.
1023
1024 Returns C<Z_OK> if successful and C<Z_STREAM_END> if the end of the
1025 compressed data has been successfully reached. 
1026
1027 If not successful C<$status> will hold the I<zlib> error code.
1028
1029 If the C<ConsumeInput> option has been set to true when the
1030 C<Compress::Raw::Zlib::Inflate> object is created, the C<$input> parameter
1031 is modified by C<inflate>. On completion it will contain what remains
1032 of the input buffer after inflation. In practice, this means that when
1033 the return status is C<Z_OK> the C<$input> parameter will contain an
1034 empty string, and when the return status is C<Z_STREAM_END> the C<$input>
1035 parameter will contains what (if anything) was stored in the input buffer
1036 after the deflated data stream.
1037
1038 This feature is useful when processing a file format that encapsulates
1039 a compressed data stream (e.g. gzip, zip) and there is useful data
1040 immediately after the deflation stream.
1041
1042 If the C<AppendOutput> option is set to true in the constructor for
1043 this object, the uncompressed data will be appended to C<$output>. If
1044 it is false, C<$output> will be truncated before any uncompressed data
1045 is written to it.
1046
1047 The C<$eof> parameter needs a bit of explanation. 
1048
1049 Prior to version 1.2.0, zlib assumed that there was at least one trailing
1050 byte immediately after the compressed data stream when it was carrying out
1051 decompression. This normally isn't a problem because the majority of zlib
1052 applications guarantee that there will be data directly after the
1053 compressed data stream.  For example, both gzip (RFC 1950) and zip both
1054 define trailing data that follows the compressed data stream.
1055
1056 The C<$eof> parameter only needs to be used if B<all> of the following
1057 conditions apply
1058
1059 =over 5
1060
1061 =item 1 
1062
1063 You are either using a copy of zlib that is older than version 1.2.0 or you
1064 want your application code to be able to run with as many different
1065 versions of zlib as possible.
1066
1067 =item 2
1068
1069 You have set the C<WindowBits> parameter to C<-MAX_WBITS> in the constructor
1070 for this object, i.e. you are uncompressing a raw deflated data stream
1071 (RFC 1951).
1072
1073 =item 3
1074
1075 There is no data immediately after the compressed data stream.
1076
1077 =back
1078
1079 If B<all> of these are the case, then you need to set the C<$eof> parameter
1080 to true on the final call (and only the final call) to C<$i-E<gt>inflate>. 
1081
1082 If you have built this module with zlib >= 1.2.0, the C<$eof> parameter is
1083 ignored. You can still set it if you want, but it won't be used behind the
1084 scenes.
1085
1086 =head2 B<$status = $i-E<gt>inflateSync($input)>
1087
1088 This method can be used to attempt to recover good data from a compressed
1089 data stream that is partially corrupt.
1090 It scans C<$input> until it reaches either a I<full flush point> or the
1091 end of the buffer.
1092
1093 If a I<full flush point> is found, C<Z_OK> is returned and C<$input>
1094 will be have all data up to the flush point removed. This data can then be
1095 passed to the C<$i-E<gt>inflate> method to be uncompressed.
1096
1097 Any other return code means that a flush point was not found. If more
1098 data is available, C<inflateSync> can be called repeatedly with more
1099 compressed data until the flush point is found.
1100
1101 Note I<full flush points> are not present by default in compressed
1102 data streams. They must have been added explicitly when the data stream
1103 was created by calling C<Compress::Deflate::flush>  with C<Z_FULL_FLUSH>.
1104
1105 =head2 B<$status = $i-E<gt>inflateReset() >
1106
1107 This method will reset the inflation object C<$i>. It can be used when you
1108 are uncompressing multiple data streams and want to use the same object to
1109 uncompress each of them. 
1110
1111 Returns C<Z_OK> if successful.
1112
1113 =head2 B<$i-E<gt>dict_adler()>
1114
1115 Returns the adler32 value for the dictionary.
1116
1117 =head2 B<$i-E<gt>crc32()>
1118
1119 Returns the crc32 value for the uncompressed data to date.
1120
1121 If the C<CRC32> option is not enabled in the constructor for this object,
1122 this method will always return 0;
1123
1124 =head2 B<$i-E<gt>adler32()>
1125
1126 Returns the adler32 value for the uncompressed data to date.
1127
1128 If the C<ADLER32> option is not enabled in the constructor for this object,
1129 this method will always return 0;
1130
1131 =head2 B<$i-E<gt>msg()>
1132
1133 Returns the last error message generated by zlib.
1134
1135 =head2 B<$i-E<gt>total_in()>
1136
1137 Returns the total number of bytes compressed bytes input to inflate.
1138
1139 =head2 B<$i-E<gt>total_out()>
1140
1141 Returns the total number of uncompressed bytes output from inflate.
1142
1143 =head2 B<$d-E<gt>get_BufSize()>
1144
1145 Returns the buffer size used to carry out the decompression.
1146
1147 =head2 Examples
1148
1149 Here is an example of using C<inflate>.
1150
1151     use strict ;
1152     use warnings ;
1153     
1154     use Compress::Raw::Zlib;
1155     
1156     my $x = new Compress::Raw::Zlib::Inflate()
1157        or die "Cannot create a inflation stream\n" ;
1158     
1159     my $input = '' ;
1160     binmode STDIN;
1161     binmode STDOUT;
1162     
1163     my ($output, $status) ;
1164     while (read(STDIN, $input, 4096))
1165     {
1166         $status = $x->inflate($input, $output) ;
1167     
1168         print $output ;
1169     
1170         last if $status != Z_OK ;
1171     }
1172     
1173     die "inflation failed\n"
1174         unless $status == Z_STREAM_END ;
1175
1176 The next example show how to use the C<LimitOutput> option. Notice the use
1177 of two nested loops in this case. The outer loop reads the data from the
1178 input source - STDIN and the inner loop repeatedly calls C<inflate> until
1179 C<$input> is exhausted, we get an error, or the end of the stream is
1180 reached. One point worth remembering is by using the C<LimitOutput> option
1181 you also get C<ConsumeInput> set as well - this makes the code below much
1182 simpler.
1183
1184     use strict ;
1185     use warnings ;
1186     
1187     use Compress::Raw::Zlib;
1188     
1189     my $x = new Compress::Raw::Zlib::Inflate(LimitOutput => 1)
1190        or die "Cannot create a inflation stream\n" ;
1191     
1192     my $input = '' ;
1193     binmode STDIN;
1194     binmode STDOUT;
1195     
1196     my ($output, $status) ;
1197
1198   OUTER:
1199     while (read(STDIN, $input, 4096))
1200     {
1201         do
1202         {
1203             $status = $x->inflate($input, $output) ;
1204
1205             print $output ;
1206
1207             last OUTER
1208                 unless $status == Z_OK || $status == Z_BUF_ERROR ;
1209         }
1210         while ($status == Z_OK && length $input);
1211     }
1212     
1213     die "inflation failed\n"
1214         unless $status == Z_STREAM_END ;
1215
1216 =head1 CHECKSUM FUNCTIONS
1217
1218 Two functions are provided by I<zlib> to calculate checksums. For the
1219 Perl interface, the order of the two parameters in both functions has
1220 been reversed. This allows both running checksums and one off
1221 calculations to be done.
1222
1223     $crc = adler32($buffer [,$crc]) ;
1224     $crc = crc32($buffer [,$crc]) ;
1225
1226 The buffer parameters can either be a scalar or a scalar reference.
1227
1228 If the $crc parameters is C<undef>, the crc value will be reset.
1229
1230 If you have built this module with zlib 1.2.3 or better, two more
1231 CRC-related functions are available.
1232
1233     $crc = adler32_combine($crc1, $crc2, $len2)l
1234     $crc = crc32_combine($adler1, $adler2, $len2)
1235
1236 These functions allow checksums to be merged.
1237
1238 =head1 Misc
1239
1240 =head2 my $version = Compress::Raw::Zlib::zlib_version();
1241
1242 Returns the version of the zlib library.
1243
1244 =head1 The LimitOutput option.
1245
1246 By default C<< $i->inflate($input, $output) >> will uncompress I<all> data
1247 in C<$input> and write I<all> of the uncompressed data it has generated to
1248 C<$output>. This makes the interface to C<inflate> much simpler - if the
1249 method has uncompressed C<$input> successfully I<all> compressed data in
1250 C<$input> will have been dealt with. So if you are reading from an input
1251 source and uncompressing as you go the code will look something like this
1252
1253     use strict ;
1254     use warnings ;
1255     
1256     use Compress::Raw::Zlib;
1257     
1258     my $x = new Compress::Raw::Zlib::Inflate()
1259        or die "Cannot create a inflation stream\n" ;
1260     
1261     my $input = '' ;
1262     
1263     my ($output, $status) ;
1264     while (read(STDIN, $input, 4096))
1265     {
1266         $status = $x->inflate($input, $output) ;
1267     
1268         print $output ;
1269     
1270         last if $status != Z_OK ;
1271     }
1272     
1273     die "inflation failed\n"
1274         unless $status == Z_STREAM_END ;
1275
1276 The points to note are 
1277
1278 =over 5
1279
1280 =item *
1281
1282 The main processing loop in the code handles reading of compressed data
1283 from STDIN.
1284
1285 =item *
1286
1287 The status code returned from C<inflate> will only trigger termination of
1288 the main processing loop if it isn't C<Z_OK>. When C<LimitOutput> has not
1289 been used the C<Z_OK> status means means that the end of the compressed
1290 data stream has been reached or there has been an error in uncompression.
1291
1292 =item *
1293
1294 After the call to C<inflate> I<all> of the uncompressed data in C<$input>
1295 will have been processed. This means the subsequent call to C<read> can
1296 overwrite it's contents without any problem.
1297
1298 =back
1299
1300 For most use-cases the behavior described above is acceptable (this module
1301 and it's predecessor, C<Compress::Zlib>, have used it for over 10 years
1302 without an issue), but in a few very specific use-cases the amount of
1303 memory required for C<$output> can prohibitively large. For example, if the
1304 compressed data stream contains the same pattern repeated thousands of
1305 times, a relatively small compressed data stream can uncompress into
1306 hundreds of megabytes.  Remember C<inflate> will keep allocating memory
1307 until I<all> the uncompressed data has been written to the output buffer -
1308 the size of C<$output> is unbounded. 
1309
1310 The C<LimitOutput> option is designed to help with this use-case.
1311
1312 The main difference in your code when using C<LimitOutput> is having to
1313 deal with cases where the C<$input> parameter still contains some
1314 uncompressed data that C<inflate> hasn't processed yet. The status code
1315 returned from C<inflate> will be C<Z_OK> if uncompression took place and
1316 C<Z_BUF_ERROR> if the output buffer is full.
1317
1318 Below is typical code that shows how to use C<LimitOutput>.
1319
1320     use strict ;
1321     use warnings ;
1322     
1323     use Compress::Raw::Zlib;
1324     
1325     my $x = new Compress::Raw::Zlib::Inflate(LimitOutput => 1)
1326        or die "Cannot create a inflation stream\n" ;
1327     
1328     my $input = '' ;
1329     binmode STDIN;
1330     binmode STDOUT;
1331     
1332     my ($output, $status) ;
1333
1334   OUTER:
1335     while (read(STDIN, $input, 4096))
1336     {
1337         do
1338         {
1339             $status = $x->inflate($input, $output) ;
1340
1341             print $output ;
1342
1343             last OUTER
1344                 unless $status == Z_OK || $status == Z_BUF_ERROR ;
1345         }
1346         while ($status == Z_OK && length $input);
1347     }
1348     
1349     die "inflation failed\n"
1350         unless $status == Z_STREAM_END ;
1351
1352 Points to note this time:
1353
1354 =over 5
1355
1356 =item *
1357
1358 There are now two nested loops in the code: the outer loop for reading the
1359 compressed data from STDIN, as before; and the inner loop to carry out the
1360 uncompression.
1361
1362 =item *
1363
1364 There are two exit points from the inner uncompression loop.
1365
1366 Firstly when C<inflate> has returned a status other than C<Z_OK> or
1367 C<Z_BUF_ERROR>.  This means that either the end of the compressed data
1368 stream has been reached (C<Z_STREAM_END>) or there is an error in the
1369 compressed data. In either of these cases there is no point in continuing
1370 with reading the compressed data, so both loops are terminated.
1371
1372 The second exit point tests if there is any data left in the input buffer,
1373 C<$input> - remember that the C<ConsumeInput> option is automatically
1374 enabled when C<LimitOutput> is used.  When the input buffer has been
1375 exhausted, the outer loop can run again and overwrite a now empty
1376 C<$input>.
1377
1378 =back
1379
1380 =head1 ACCESSING ZIP FILES
1381
1382 Although it is possible (with some effort on your part) to use this module
1383 to access .zip files, there are other perl modules available that will
1384 do all the hard work for you. Check out C<Archive::Zip>,
1385 C<IO::Compress::Zip> and C<IO::Uncompress::Unzip>.
1386
1387 =head1 CONSTANTS
1388
1389 All the I<zlib> constants are automatically imported when you make use
1390 of I<Compress::Raw::Zlib>.
1391
1392 =head1 SEE ALSO
1393
1394 L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
1395
1396 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1397
1398 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1399 L<Archive::Tar|Archive::Tar>,
1400 L<IO::Zlib|IO::Zlib>
1401
1402 For RFC 1950, 1951 and 1952 see 
1403 F<http://www.faqs.org/rfcs/rfc1950.html>,
1404 F<http://www.faqs.org/rfcs/rfc1951.html> and
1405 F<http://www.faqs.org/rfcs/rfc1952.html>
1406
1407 The I<zlib> compression library was written by Jean-loup Gailly
1408 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1409
1410 The primary site for the I<zlib> compression library is
1411 F<http://www.zlib.org>.
1412
1413 The primary site for gzip is F<http://www.gzip.org>.
1414
1415 =head1 AUTHOR
1416
1417 This module was written by Paul Marquess, F<pmqs@cpan.org>. 
1418
1419 =head1 MODIFICATION HISTORY
1420
1421 See the Changes file.
1422
1423 =head1 COPYRIGHT AND LICENSE
1424
1425 Copyright (c) 2005-2011 Paul Marquess. All rights reserved.
1426
1427 This program is free software; you can redistribute it and/or
1428 modify it under the same terms as Perl itself.
1429