This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
e6e15c9700f3d38d69b74897569b187cb9074dd1
[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.030';
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->dict_adler() ;
568     $d->crc32() ;
569     $d->adler32() ;
570     $i->total_in() ;
571     $i->total_out() ;
572     $i->msg() ;
573     $d->get_BufSize();
574
575     $crc = adler32($buffer [,$crc]) ;
576     $crc = crc32($buffer [,$crc]) ;
577
578     $crc = adler32_combine($crc1, $crc2, $len2)l
579     $crc = crc32_combine($adler1, $adler2, $len2)
580
581     my $version = Compress::Raw::Zlib::zlib_version();
582
583 =head1 DESCRIPTION
584
585 The I<Compress::Raw::Zlib> module provides a Perl interface to the I<zlib>
586 compression library (see L</AUTHOR> for details about where to get
587 I<zlib>). 
588
589 =head1 Compress::Raw::Zlib::Deflate
590
591 This section defines an interface that allows in-memory compression using
592 the I<deflate> interface provided by zlib.
593
594 Here is a definition of the interface available:
595
596 =head2 B<($d, $status) = new Compress::Raw::Zlib::Deflate( [OPT] ) >
597
598 Initialises a deflation object. 
599
600 If you are familiar with the I<zlib> library, it combines the
601 features of the I<zlib> functions C<deflateInit>, C<deflateInit2>
602 and C<deflateSetDictionary>.
603
604 If successful, it will return the initialised deflation object, C<$d>
605 and a C<$status> of C<Z_OK> in a list context. In scalar context it
606 returns the deflation object, C<$d>, only.
607
608 If not successful, the returned deflation object, C<$d>, will be
609 I<undef> and C<$status> will hold the a I<zlib> error code.
610
611 The function optionally takes a number of named options specified as
612 C<< Name => value >> pairs. This allows individual options to be
613 tailored without having to specify them all in the parameter list.
614
615 For backward compatibility, it is also possible to pass the parameters
616 as a reference to a hash containing the name=>value pairs.
617
618 Below is a list of the valid options:
619
620 =over 5
621
622 =item B<-Level>
623
624 Defines the compression level. Valid values are 0 through 9,
625 C<Z_NO_COMPRESSION>, C<Z_BEST_SPEED>, C<Z_BEST_COMPRESSION>, and
626 C<Z_DEFAULT_COMPRESSION>.
627
628 The default is C<Z_DEFAULT_COMPRESSION>.
629
630 =item B<-Method>
631
632 Defines the compression method. The only valid value at present (and
633 the default) is C<Z_DEFLATED>.
634
635 =item B<-WindowBits>
636
637 To compress an RFC 1950 data stream, set C<WindowBits> to a positive
638 number between 8 and 15.
639
640 To compress an RFC 1951 data stream, set C<WindowBits> to C<-MAX_WBITS>.
641
642 To compress an RFC 1952 data stream (i.e. gzip), set C<WindowBits> to
643 C<WANT_GZIP>.
644
645 For a definition of the meaning and valid values for C<WindowBits>
646 refer to the I<zlib> documentation for I<deflateInit2>.
647
648 Defaults to C<MAX_WBITS>.
649
650 =item B<-MemLevel>
651
652 For a definition of the meaning and valid values for C<MemLevel>
653 refer to the I<zlib> documentation for I<deflateInit2>.
654
655 Defaults to MAX_MEM_LEVEL.
656
657 =item B<-Strategy>
658
659 Defines the strategy used to tune the compression. The valid values are
660 C<Z_DEFAULT_STRATEGY>, C<Z_FILTERED>, C<Z_RLE>, C<Z_FIXED> and
661 C<Z_HUFFMAN_ONLY>.
662
663 The default is C<Z_DEFAULT_STRATEGY>.
664
665 =item B<-Dictionary>
666
667 When a dictionary is specified I<Compress::Raw::Zlib> will automatically
668 call C<deflateSetDictionary> directly after calling C<deflateInit>. The
669 Adler32 value for the dictionary can be obtained by calling the method 
670 C<$d-E<gt>dict_adler()>.
671
672 The default is no dictionary.
673
674 =item B<-Bufsize>
675
676 Sets the initial size for the output buffer used by the C<$d-E<gt>deflate>
677 and C<$d-E<gt>flush> methods. If the buffer has to be
678 reallocated to increase the size, it will grow in increments of
679 C<Bufsize>.
680
681 The default buffer size is 4096.
682
683 =item B<-AppendOutput>
684
685 This option controls how data is written to the output buffer by the
686 C<$d-E<gt>deflate> and C<$d-E<gt>flush> methods.
687
688 If the C<AppendOutput> option is set to false, the output buffers in the
689 C<$d-E<gt>deflate> and C<$d-E<gt>flush>  methods will be truncated before
690 uncompressed data is written to them.
691
692 If the option is set to true, uncompressed data will be appended to the
693 output buffer in the C<$d-E<gt>deflate> and C<$d-E<gt>flush> methods.
694
695 This option defaults to false.
696
697 =item B<-CRC32>
698
699 If set to true, a crc32 checksum of the uncompressed data will be
700 calculated. Use the C<$d-E<gt>crc32> method to retrieve this value.
701
702 This option defaults to false.
703
704 =item B<-ADLER32>
705
706 If set to true, an adler32 checksum of the uncompressed data will be
707 calculated. Use the C<$d-E<gt>adler32> method to retrieve this value.
708
709 This option defaults to false.
710
711 =back
712
713 Here is an example of using the C<Compress::Raw::Zlib::Deflate> optional
714 parameter list to override the default buffer size and compression
715 level. All other options will take their default values.
716
717     my $d = new Compress::Raw::Zlib::Deflate ( -Bufsize => 300, 
718                                                -Level   => Z_BEST_SPEED ) ;
719
720 =head2 B<$status = $d-E<gt>deflate($input, $output)>
721
722 Deflates the contents of C<$input> and writes the compressed data to
723 C<$output>.
724
725 The C<$input> and C<$output> parameters can be either scalars or scalar
726 references.
727
728 When finished, C<$input> will be completely processed (assuming there
729 were no errors). If the deflation was successful it writes the deflated
730 data to C<$output> and returns a status value of C<Z_OK>.
731
732 On error, it returns a I<zlib> error code.
733
734 If the C<AppendOutput> option is set to true in the constructor for
735 the C<$d> object, the compressed data will be appended to C<$output>. If
736 it is false, C<$output> will be truncated before any compressed data is
737 written to it.
738
739 B<Note>: This method will not necessarily write compressed data to
740 C<$output> every time it is called. So do not assume that there has been
741 an error if the contents of C<$output> is empty on returning from
742 this method. As long as the return code from the method is C<Z_OK>,
743 the deflate has succeeded.
744
745 =head2 B<$status = $d-E<gt>flush($output [, $flush_type]) >
746
747 Typically used to finish the deflation. Any pending output will be
748 written to C<$output>.
749
750 Returns C<Z_OK> if successful.
751
752 Note that flushing can seriously degrade the compression ratio, so it
753 should only be used to terminate a decompression (using C<Z_FINISH>) or
754 when you want to create a I<full flush point> (using C<Z_FULL_FLUSH>).
755
756 By default the C<flush_type> used is C<Z_FINISH>. Other valid values
757 for C<flush_type> are C<Z_NO_FLUSH>, C<Z_PARTIAL_FLUSH>, C<Z_SYNC_FLUSH>
758 and C<Z_FULL_FLUSH>. It is strongly recommended that you only set the
759 C<flush_type> parameter if you fully understand the implications of
760 what it does. See the C<zlib> documentation for details.
761
762 If the C<AppendOutput> option is set to true in the constructor for
763 the C<$d> object, the compressed data will be appended to C<$output>. If
764 it is false, C<$output> will be truncated before any compressed data is
765 written to it.
766
767 =head2 B<$status = $d-E<gt>deflateReset() >
768
769 This method will reset the deflation object C<$d>. It can be used when you
770 are compressing multiple data streams and want to use the same object to
771 compress each of them. It should only be used once the previous data stream
772 has been flushed successfully, i.e. a call to C<< $d->flush(Z_FINISH) >> has
773 returned C<Z_OK>.
774
775 Returns C<Z_OK> if successful.
776
777 =head2 B<$status = $d-E<gt>deflateParams([OPT])>
778
779 Change settings for the deflate object C<$d>.
780
781 The list of the valid options is shown below. Options not specified
782 will remain unchanged.
783
784 =over 5
785
786 =item B<-Level>
787
788 Defines the compression level. Valid values are 0 through 9,
789 C<Z_NO_COMPRESSION>, C<Z_BEST_SPEED>, C<Z_BEST_COMPRESSION>, and
790 C<Z_DEFAULT_COMPRESSION>.
791
792 =item B<-Strategy>
793
794 Defines the strategy used to tune the compression. The valid values are
795 C<Z_DEFAULT_STRATEGY>, C<Z_FILTERED> and C<Z_HUFFMAN_ONLY>. 
796
797 =item B<-BufSize>
798
799 Sets the initial size for the output buffer used by the C<$d-E<gt>deflate>
800 and C<$d-E<gt>flush> methods. If the buffer has to be
801 reallocated to increase the size, it will grow in increments of
802 C<Bufsize>.
803
804 =back
805
806 =head2 B<$status = $d-E<gt>deflateTune($good_length, $max_lazy, $nice_length, $max_chain)>
807
808 Tune the internal settings for the deflate object C<$d>. This option is
809 only available if you are running zlib 1.2.2.3 or better.
810
811 Refer to the documentation in zlib.h for instructions on how to fly
812 C<deflateTune>.
813
814 =head2 B<$d-E<gt>dict_adler()>
815
816 Returns the adler32 value for the dictionary.
817
818 =head2 B<$d-E<gt>crc32()>
819
820 Returns the crc32 value for the uncompressed data to date. 
821
822 If the C<CRC32> option is not enabled in the constructor for this object,
823 this method will always return 0;
824
825 =head2 B<$d-E<gt>adler32()>
826
827 Returns the adler32 value for the uncompressed data to date. 
828
829 =head2 B<$d-E<gt>msg()>
830
831 Returns the last error message generated by zlib.
832
833 =head2 B<$d-E<gt>total_in()>
834
835 Returns the total number of bytes uncompressed bytes input to deflate.
836
837 =head2 B<$d-E<gt>total_out()>
838
839 Returns the total number of compressed bytes output from deflate.
840
841 =head2 B<$d-E<gt>get_Strategy()>
842
843 Returns the deflation strategy currently used. Valid values are
844 C<Z_DEFAULT_STRATEGY>, C<Z_FILTERED> and C<Z_HUFFMAN_ONLY>. 
845
846 =head2 B<$d-E<gt>get_Level()>
847
848 Returns the compression level being used. 
849
850 =head2 B<$d-E<gt>get_BufSize()>
851
852 Returns the buffer size used to carry out the compression.
853
854 =head2 Example
855
856 Here is a trivial example of using C<deflate>. It simply reads standard
857 input, deflates it and writes it to standard output.
858
859     use strict ;
860     use warnings ;
861
862     use Compress::Raw::Zlib ;
863
864     binmode STDIN;
865     binmode STDOUT;
866     my $x = new Compress::Raw::Zlib::Deflate
867        or die "Cannot create a deflation stream\n" ;
868
869     my ($output, $status) ;
870     while (<>)
871     {
872         $status = $x->deflate($_, $output) ;
873     
874         $status == Z_OK
875             or die "deflation failed\n" ;
876     
877         print $output ;
878     }
879     
880     $status = $x->flush($output) ;
881     
882     $status == Z_OK
883         or die "deflation failed\n" ;
884     
885     print $output ;
886
887 =head1 Compress::Raw::Zlib::Inflate
888
889 This section defines an interface that allows in-memory uncompression using
890 the I<inflate> interface provided by zlib.
891
892 Here is a definition of the interface:
893
894 =head2 B< ($i, $status) = new Compress::Raw::Zlib::Inflate( [OPT] ) >
895
896 Initialises an inflation object. 
897
898 In a list context it returns the inflation object, C<$i>, and the
899 I<zlib> status code (C<$status>). In a scalar context it returns the
900 inflation object only.
901
902 If successful, C<$i> will hold the inflation object and C<$status> will
903 be C<Z_OK>.
904
905 If not successful, C<$i> will be I<undef> and C<$status> will hold the
906 I<zlib> error code.
907
908 The function optionally takes a number of named options specified as
909 C<< -Name => value >> pairs. This allows individual options to be
910 tailored without having to specify them all in the parameter list.
911
912 For backward compatibility, it is also possible to pass the parameters
913 as a reference to a hash containing the C<< name=>value >> pairs.
914
915 Here is a list of the valid options:
916
917 =over 5
918
919 =item B<-WindowBits>
920
921 To uncompress an RFC 1950 data stream, set C<WindowBits> to a positive
922 number between 8 and 15.
923
924 To uncompress an RFC 1951 data stream, set C<WindowBits> to C<-MAX_WBITS>.
925
926 To uncompress an RFC 1952 data stream (i.e. gzip), set C<WindowBits> to
927 C<WANT_GZIP>.
928
929 To auto-detect and uncompress an RFC 1950 or RFC 1952 data stream (i.e.
930 gzip), set C<WindowBits> to C<WANT_GZIP_OR_ZLIB>.
931
932 For a full definition of the meaning and valid values for C<WindowBits>
933 refer to the I<zlib> documentation for I<inflateInit2>.
934
935 Defaults to C<MAX_WBITS>.
936
937 =item B<-Bufsize>
938
939 Sets the initial size for the output buffer used by the C<$i-E<gt>inflate>
940 method. If the output buffer in this method has to be reallocated to
941 increase the size, it will grow in increments of C<Bufsize>.
942
943 Default is 4096.
944
945 =item B<-Dictionary>
946
947 The default is no dictionary.
948
949 =item B<-AppendOutput>
950
951 This option controls how data is written to the output buffer by the
952 C<$i-E<gt>inflate> method.
953
954 If the option is set to false, the output buffer in the C<$i-E<gt>inflate>
955 method will be truncated before uncompressed data is written to it.
956
957 If the option is set to true, uncompressed data will be appended to the
958 output buffer by the C<$i-E<gt>inflate> method.
959
960 This option defaults to false.
961
962 =item B<-CRC32>
963
964 If set to true, a crc32 checksum of the uncompressed data will be
965 calculated. Use the C<$i-E<gt>crc32> method to retrieve this value.
966
967 This option defaults to false.
968
969 =item B<-ADLER32>
970
971 If set to true, an adler32 checksum of the uncompressed data will be
972 calculated. Use the C<$i-E<gt>adler32> method to retrieve this value.
973
974 This option defaults to false.
975
976 =item B<-ConsumeInput>
977
978 If set to true, this option will remove compressed data from the input
979 buffer of the C<< $i->inflate >> method as the inflate progresses.
980
981 This option can be useful when you are processing compressed data that is
982 embedded in another file/buffer. In this case the data that immediately
983 follows the compressed stream will be left in the input buffer.
984
985 This option defaults to true.
986
987 =item B<-LimitOutput>
988
989 The C<LimitOutput> option changes the behavior of the C<< $i->inflate >>
990 method so that the amount of memory used by the output buffer can be
991 limited. 
992
993 When C<LimitOutput> is used the size of the output buffer used will either
994 be the value of the C<Bufsize> option or the amount of memory already
995 allocated to C<$output>, whichever is larger. Predicting the output size
996 available is tricky, so don't rely on getting an exact output buffer size.
997
998 When C<LimitOutout> is not specified C<< $i->inflate >> will use as much
999 memory as it takes to write all the uncompressed data it creates by
1000 uncompressing the input buffer.
1001
1002 If C<LimitOutput> is enabled, the C<ConsumeInput> option will also be
1003 enabled.
1004
1005 This option defaults to false.
1006
1007 See L</The LimitOutput option> for a discussion on why C<LimitOutput> is
1008 needed and how to use it.
1009
1010 =back
1011
1012 Here is an example of using an optional parameter to override the default
1013 buffer size.
1014
1015     my ($i, $status) = new Compress::Raw::Zlib::Inflate( -Bufsize => 300 ) ;
1016
1017 =head2 B< $status = $i-E<gt>inflate($input, $output [,$eof]) >
1018
1019 Inflates the complete contents of C<$input> and writes the uncompressed
1020 data to C<$output>. The C<$input> and C<$output> parameters can either be
1021 scalars or scalar references.
1022
1023 Returns C<Z_OK> if successful and C<Z_STREAM_END> if the end of the
1024 compressed data has been successfully reached. 
1025
1026 If not successful C<$status> will hold the I<zlib> error code.
1027
1028 If the C<ConsumeInput> option has been set to true when the
1029 C<Compress::Raw::Zlib::Inflate> object is created, the C<$input> parameter
1030 is modified by C<inflate>. On completion it will contain what remains
1031 of the input buffer after inflation. In practice, this means that when
1032 the return status is C<Z_OK> the C<$input> parameter will contain an
1033 empty string, and when the return status is C<Z_STREAM_END> the C<$input>
1034 parameter will contains what (if anything) was stored in the input buffer
1035 after the deflated data stream.
1036
1037 This feature is useful when processing a file format that encapsulates
1038 a compressed data stream (e.g. gzip, zip) and there is useful data
1039 immediately after the deflation stream.
1040
1041 If the C<AppendOutput> option is set to true in the constructor for
1042 this object, the uncompressed data will be appended to C<$output>. If
1043 it is false, C<$output> will be truncated before any uncompressed data
1044 is written to it.
1045
1046 The C<$eof> parameter needs a bit of explanation. 
1047
1048 Prior to version 1.2.0, zlib assumed that there was at least one trailing
1049 byte immediately after the compressed data stream when it was carrying out
1050 decompression. This normally isn't a problem because the majority of zlib
1051 applications guarantee that there will be data directly after the
1052 compressed data stream.  For example, both gzip (RFC 1950) and zip both
1053 define trailing data that follows the compressed data stream.
1054
1055 The C<$eof> parameter only needs to be used if B<all> of the following
1056 conditions apply
1057
1058 =over 5
1059
1060 =item 1 
1061
1062 You are either using a copy of zlib that is older than version 1.2.0 or you
1063 want your application code to be able to run with as many different
1064 versions of zlib as possible.
1065
1066 =item 2
1067
1068 You have set the C<WindowBits> parameter to C<-MAX_WBITS> in the constructor
1069 for this object, i.e. you are uncompressing a raw deflated data stream
1070 (RFC 1951).
1071
1072 =item 3
1073
1074 There is no data immediately after the compressed data stream.
1075
1076 =back
1077
1078 If B<all> of these are the case, then you need to set the C<$eof> parameter
1079 to true on the final call (and only the final call) to C<$i-E<gt>inflate>. 
1080
1081 If you have built this module with zlib >= 1.2.0, the C<$eof> parameter is
1082 ignored. You can still set it if you want, but it won't be used behind the
1083 scenes.
1084
1085 =head2 B<$status = $i-E<gt>inflateSync($input)>
1086
1087 This method can be used to attempt to recover good data from a compressed
1088 data stream that is partially corrupt.
1089 It scans C<$input> until it reaches either a I<full flush point> or the
1090 end of the buffer.
1091
1092 If a I<full flush point> is found, C<Z_OK> is returned and C<$input>
1093 will be have all data up to the flush point removed. This data can then be
1094 passed to the C<$i-E<gt>inflate> method to be uncompressed.
1095
1096 Any other return code means that a flush point was not found. If more
1097 data is available, C<inflateSync> can be called repeatedly with more
1098 compressed data until the flush point is found.
1099
1100 Note I<full flush points> are not present by default in compressed
1101 data streams. They must have been added explicitly when the data stream
1102 was created by calling C<Compress::Deflate::flush>  with C<Z_FULL_FLUSH>.
1103
1104 =head2 B<$i-E<gt>dict_adler()>
1105
1106 Returns the adler32 value for the dictionary.
1107
1108 =head2 B<$i-E<gt>crc32()>
1109
1110 Returns the crc32 value for the uncompressed data to date.
1111
1112 If the C<CRC32> option is not enabled in the constructor for this object,
1113 this method will always return 0;
1114
1115 =head2 B<$i-E<gt>adler32()>
1116
1117 Returns the adler32 value for the uncompressed data to date.
1118
1119 If the C<ADLER32> option is not enabled in the constructor for this object,
1120 this method will always return 0;
1121
1122 =head2 B<$i-E<gt>msg()>
1123
1124 Returns the last error message generated by zlib.
1125
1126 =head2 B<$i-E<gt>total_in()>
1127
1128 Returns the total number of bytes compressed bytes input to inflate.
1129
1130 =head2 B<$i-E<gt>total_out()>
1131
1132 Returns the total number of uncompressed bytes output from inflate.
1133
1134 =head2 B<$d-E<gt>get_BufSize()>
1135
1136 Returns the buffer size used to carry out the decompression.
1137
1138 =head2 Examples
1139
1140 Here is an example of using C<inflate>.
1141
1142     use strict ;
1143     use warnings ;
1144     
1145     use Compress::Raw::Zlib;
1146     
1147     my $x = new Compress::Raw::Zlib::Inflate()
1148        or die "Cannot create a inflation stream\n" ;
1149     
1150     my $input = '' ;
1151     binmode STDIN;
1152     binmode STDOUT;
1153     
1154     my ($output, $status) ;
1155     while (read(STDIN, $input, 4096))
1156     {
1157         $status = $x->inflate($input, $output) ;
1158     
1159         print $output ;
1160     
1161         last if $status != Z_OK ;
1162     }
1163     
1164     die "inflation failed\n"
1165         unless $status == Z_STREAM_END ;
1166
1167 The next example show how to use the C<LimitOutput> option. Notice the use
1168 of two nested loops in this case. The outer loop reads the data from the
1169 input source - STDIN and the inner loop repeatedly calls C<inflate> until
1170 C<$input> is exhausted, we get an error, or the end of the stream is
1171 reached. One point worth remembering is by using the C<LimitOutput> option
1172 you also get C<ConsumeInput> set as well - this makes the code below much
1173 simpler.
1174
1175     use strict ;
1176     use warnings ;
1177     
1178     use Compress::Raw::Zlib;
1179     
1180     my $x = new Compress::Raw::Zlib::Inflate(LimitOutput => 1)
1181        or die "Cannot create a inflation stream\n" ;
1182     
1183     my $input = '' ;
1184     binmode STDIN;
1185     binmode STDOUT;
1186     
1187     my ($output, $status) ;
1188
1189   OUTER:
1190     while (read(STDIN, $input, 4096))
1191     {
1192         do
1193         {
1194             $status = $x->inflate($input, $output) ;
1195
1196             print $output ;
1197
1198             last OUTER
1199                 unless $status == Z_OK || $status == Z_BUF_ERROR ;
1200         }
1201         while ($status == Z_OK && length $input);
1202     }
1203     
1204     die "inflation failed\n"
1205         unless $status == Z_STREAM_END ;
1206
1207 =head1 CHECKSUM FUNCTIONS
1208
1209 Two functions are provided by I<zlib> to calculate checksums. For the
1210 Perl interface, the order of the two parameters in both functions has
1211 been reversed. This allows both running checksums and one off
1212 calculations to be done.
1213
1214     $crc = adler32($buffer [,$crc]) ;
1215     $crc = crc32($buffer [,$crc]) ;
1216
1217 The buffer parameters can either be a scalar or a scalar reference.
1218
1219 If the $crc parameters is C<undef>, the crc value will be reset.
1220
1221 If you have built this module with zlib 1.2.3 or better, two more
1222 CRC-related functions are available.
1223
1224     $crc = adler32_combine($crc1, $crc2, $len2)l
1225     $crc = crc32_combine($adler1, $adler2, $len2)
1226
1227 These functions allow checksums to be merged.
1228
1229 =head1 Misc
1230
1231 =head2 my $version = Compress::Raw::Zlib::zlib_version();
1232
1233 Returns the version of the zlib library.
1234
1235 =head1 The LimitOutput option.
1236
1237 By default C<< $i->inflate($input, $output) >> will uncompress I<all> data
1238 in C<$input> and write I<all> of the uncompressed data it has generated to
1239 C<$output>. This makes the interface to C<inflate> much simpler - if the
1240 method has uncompressed C<$input> successfully I<all> compressed data in
1241 C<$input> will have been dealt with. So if you are reading from an input
1242 source and uncompressing as you go the code will look something like this
1243
1244     use strict ;
1245     use warnings ;
1246     
1247     use Compress::Raw::Zlib;
1248     
1249     my $x = new Compress::Raw::Zlib::Inflate()
1250        or die "Cannot create a inflation stream\n" ;
1251     
1252     my $input = '' ;
1253     
1254     my ($output, $status) ;
1255     while (read(STDIN, $input, 4096))
1256     {
1257         $status = $x->inflate($input, $output) ;
1258     
1259         print $output ;
1260     
1261         last if $status != Z_OK ;
1262     }
1263     
1264     die "inflation failed\n"
1265         unless $status == Z_STREAM_END ;
1266
1267 The points to note are 
1268
1269 =over 5
1270
1271 =item *
1272
1273 The main processing loop in the code handles reading of compressed data
1274 from STDIN.
1275
1276 =item *
1277
1278 The status code returned from C<inflate> will only trigger termination of
1279 the main processing loop if it isn't C<Z_OK>. When C<LimitOutput> has not
1280 been used the C<Z_OK> status means means that the end of the compressed
1281 data stream has been reached or there has been an error in uncompression.
1282
1283 =item *
1284
1285 After the call to C<inflate> I<all> of the uncompressed data in C<$input>
1286 will have been processed. This means the subsequent call to C<read> can
1287 overwrite it's contents without any problem.
1288
1289 =back
1290
1291 For most use-cases the behavior described above is acceptable (this module
1292 and it's predecessor, C<Compress::Zlib>, have used it for over 10 years
1293 without an issue), but in a few very specific use-cases the amount of
1294 memory required for C<$output> can prohibitively large. For example, if the
1295 compressed data stream contains the same pattern repeated thousands of
1296 times, a relatively small compressed data stream can uncompress into
1297 hundreds of megabytes.  Remember C<inflate> will keep allocating memory
1298 until I<all> the uncompressed data has been written to the output buffer -
1299 the size of C<$output> is unbounded. 
1300
1301 The C<LimitOutput> option is designed to help with this use-case.
1302
1303 The main difference in your code when using C<LimitOutput> is having to
1304 deal with cases where the C<$input> parameter still contains some
1305 uncompressed data that C<inflate> hasn't processed yet. The status code
1306 returned from C<inflate> will be C<Z_OK> if uncompression took place and
1307 C<Z_BUF_ERROR> if the output buffer is full.
1308
1309 Below is typical code that shows how to use C<LimitOutput>.
1310
1311     use strict ;
1312     use warnings ;
1313     
1314     use Compress::Raw::Zlib;
1315     
1316     my $x = new Compress::Raw::Zlib::Inflate(LimitOutput => 1)
1317        or die "Cannot create a inflation stream\n" ;
1318     
1319     my $input = '' ;
1320     binmode STDIN;
1321     binmode STDOUT;
1322     
1323     my ($output, $status) ;
1324
1325   OUTER:
1326     while (read(STDIN, $input, 4096))
1327     {
1328         do
1329         {
1330             $status = $x->inflate($input, $output) ;
1331
1332             print $output ;
1333
1334             last OUTER
1335                 unless $status == Z_OK || $status == Z_BUF_ERROR ;
1336         }
1337         while ($status == Z_OK && length $input);
1338     }
1339     
1340     die "inflation failed\n"
1341         unless $status == Z_STREAM_END ;
1342
1343 Points to note this time:
1344
1345 =over 5
1346
1347 =item *
1348
1349 There are now two nested loops in the code: the outer loop for reading the
1350 compressed data from STDIN, as before; and the inner loop to carry out the
1351 uncompression.
1352
1353 =item *
1354
1355 There are two exit points from the inner uncompression loop.
1356
1357 Firstly when C<inflate> has returned a status other than C<Z_OK> or
1358 C<Z_BUF_ERROR>.  This means that either the end of the compressed data
1359 stream has been reached (C<Z_STREAM_END>) or there is an error in the
1360 compressed data. In either of these cases there is no point in continuing
1361 with reading the compressed data, so both loops are terminated.
1362
1363 The second exit point tests if there is any data left in the input buffer,
1364 C<$input> - remember that the C<ConsumeInput> option is automatically
1365 enabled when C<LimitOutput> is used.  When the input buffer has been
1366 exhausted, the outer loop can run again and overwrite a now empty
1367 C<$input>.
1368
1369 =back
1370
1371 =head1 ACCESSING ZIP FILES
1372
1373 Although it is possible (with some effort on your part) to use this module
1374 to access .zip files, there are other perl modules available that will
1375 do all the hard work for you. Check out C<Archive::Zip>,
1376 C<IO::Compress::Zip> and C<IO::Uncompress::Unzip>.
1377
1378 =head1 CONSTANTS
1379
1380 All the I<zlib> constants are automatically imported when you make use
1381 of I<Compress::Raw::Zlib>.
1382
1383 =head1 SEE ALSO
1384
1385 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>
1386
1387 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1388
1389 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1390 L<Archive::Tar|Archive::Tar>,
1391 L<IO::Zlib|IO::Zlib>
1392
1393 For RFC 1950, 1951 and 1952 see 
1394 F<http://www.faqs.org/rfcs/rfc1950.html>,
1395 F<http://www.faqs.org/rfcs/rfc1951.html> and
1396 F<http://www.faqs.org/rfcs/rfc1952.html>
1397
1398 The I<zlib> compression library was written by Jean-loup Gailly
1399 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1400
1401 The primary site for the I<zlib> compression library is
1402 F<http://www.zlib.org>.
1403
1404 The primary site for gzip is F<http://www.gzip.org>.
1405
1406 =head1 AUTHOR
1407
1408 This module was written by Paul Marquess, F<pmqs@cpan.org>. 
1409
1410 =head1 MODIFICATION HISTORY
1411
1412 See the Changes file.
1413
1414 =head1 COPYRIGHT AND LICENSE
1415
1416 Copyright (c) 2005-2010 Paul Marquess. All rights reserved.
1417
1418 This program is free software; you can redistribute it and/or
1419 modify it under the same terms as Perl itself.
1420