ext/Compress/IO/Zlib/lib/IO/Uncompress/AnyInflate.pm

   1 package IO::Uncompress::AnyInflate ;
   2
   3 # for RFC1950, RFC1951 or RFC1952
   4
   5 use strict;
   6 use warnings;
   7 use bytes;
   8
   9 use IO::Compress::Base::Common qw(createSelfTiedObject);
  10
  11 use IO::Uncompress::Adapter::Inflate ();
  12
  13
  14 use IO::Uncompress::Base ;
  15 use IO::Uncompress::Gunzip ;
  16 use IO::Uncompress::Inflate ;
  17 use IO::Uncompress::RawInflate ;
  18 use IO::Uncompress::Unzip ;
  19
  20 require Exporter ;
  21
  22 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $AnyInflateError);
  23
  24 $VERSION = '2.000_08';
  25 $AnyInflateError = '';
  26
  27 @ISA = qw( Exporter IO::Uncompress::Base );
  28 @EXPORT_OK = qw( $AnyInflateError anyinflate ) ;
  29 %EXPORT_TAGS = %IO::Uncompress::Base::DEFLATE_CONSTANTS ;
  30 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
  31 Exporter::export_ok_tags('all');
  32
  33 # TODO - allow the user to pick a set of the three formats to allow
  34 #        or just assume want to auto-detect any of the three formats.
  35
  36 sub new
  37 {
  38     my $class = shift ;
  39     my $obj = createSelfTiedObject($class, \$AnyInflateError);
  40     $obj->_create(undef, 0, @_);
  41 }
  42
  43 sub anyinflate
  44 {
  45     my $obj = createSelfTiedObject(undef, \$AnyInflateError);
  46     return $obj->_inf(@_) ;
  47 }
  48
  49 sub getExtraParams
  50 {
  51     return ();
  52 }
  53
  54 sub ckParams
  55 {
  56     my $self = shift ;
  57     my $got = shift ;
  58
  59     # any always needs both crc32 and adler32
  60     $got->value('CRC32' => 1);
  61     $got->value('ADLER32' => 1);
  62
  63     return 1;
  64 }
  65
  66 sub mkUncomp
  67 {
  68     my $self = shift ;
  69     my $class = shift ;
  70     my $got = shift ;
  71
  72     my ($obj, $errstr, $errno) = IO::Uncompress::Adapter::Inflate::mkUncompObject();
  73
  74     return $self->saveErrorString(undef, $errstr, $errno)
  75         if ! defined $obj;
  76
  77     *$self->{Uncomp} = $obj;
  78
  79      my $magic = $self->ckMagic( qw( RawInflate Inflate Gunzip Unzip ) );
  80
  81      if ($magic) {
  82         *$self->{Info} = $self->readHeader($magic)
  83             or return undef ;
  84
  85         return 1;
  86      }
  87
  88      return 0 ;
  89 }
  90
  91
  92
  93 sub ckMagic
  94 {
  95     my $self = shift;
  96     my @names = @_ ;
  97
  98     my $keep = ref $self ;
  99     for my $class ( map { "IO::Uncompress::$_" } @names)
 100     {
 101         bless $self => $class;
 102         my $magic = $self->ckMagic();
 103
 104         if ($magic)
 105         {
 106             #bless $self => $class;
 107             return $magic ;
 108         }
 109
 110         $self->pushBack(*$self->{HeaderPending})  ;
 111         *$self->{HeaderPending} = ''  ;
 112     }
 113
 114     bless $self => $keep;
 115     return undef;
 116 }
 117
 118 1 ;
 119
 120 __END__
 121
 122
 123 =head1 NAME
 124
 125
 126 IO::Uncompress::AnyInflate - Perl interface to read RFC 1950, 1951 & 1952 files/buffers
 127
 128
 129 =head1 SYNOPSIS
 130
 131     use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
 132
 133     my $status = anyinflate $input => $output [,OPTS]
 134         or die "anyinflate failed: $AnyInflateError\n";
 135
 136     my $z = new IO::Uncompress::AnyInflate $input [OPTS]
 137         or die "anyinflate failed: $AnyInflateError\n";
 138
 139     $status = $z->read($buffer)
 140     $status = $z->read($buffer, $length)
 141     $status = $z->read($buffer, $length, $offset)
 142     $line = $z->getline()
 143     $char = $z->getc()
 144     $char = $z->ungetc()
 145     $char = $z->opened()
 146
 147     $status = $z->inflateSync()
 148
 149     $z->trailingData()
 150     $data = $z->getHeaderInfo()
 151     $z->tell()
 152     $z->seek($position, $whence)
 153     $z->binmode()
 154     $z->fileno()
 155     $z->eof()
 156     $z->close()
 157
 158     $AnyInflateError ;
 159
 160     # IO::File mode
 161
 162     <$z>
 163     read($z, $buffer);
 164     read($z, $buffer, $length);
 165     read($z, $buffer, $length, $offset);
 166     tell($z)
 167     seek($z, $position, $whence)
 168     binmode($z)
 169     fileno($z)
 170     eof($z)
 171     close($z)
 172
 173
 174 =head1 DESCRIPTION
 175
 176
 177
 178 B<WARNING -- This is a Beta release>.
 179
 180 =over 5
 181
 182 =item * DO NOT use in production code.
 183
 184 =item * The documentation is incomplete in places.
 185
 186 =item * Parts of the interface defined here are tentative.
 187
 188 =item * Please report any problems you find.
 189
 190 =back
 191
 192
 193
 194
 195
 196 This module provides a Perl interface that allows the reading of
 197 files/buffers that conform to RFC's 1950, 1951 and 1952.
 198
 199 The module will auto-detect which, if any, of the three supported
 200 compression formats is being used.
 201
 202
 203
 204 =head1 Functional Interface
 205
 206 A top-level function, C<anyinflate>, is provided to carry out
 207 "one-shot" uncompression between buffers and/or files. For finer
 208 control over the uncompression process, see the L</"OO Interface">
 209 section.
 210
 211     use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
 212
 213     anyinflate $input => $output [,OPTS]
 214         or die "anyinflate failed: $AnyInflateError\n";
 215
 216
 217
 218 The functional interface needs Perl5.005 or better.
 219
 220
 221 =head2 anyinflate $input => $output [, OPTS]
 222
 223
 224 C<anyinflate> expects at least two parameters, C<$input> and C<$output>.
 225
 226 =head3 The C<$input> parameter
 227
 228 The parameter, C<$input>, is used to define the source of
 229 the compressed data.
 230
 231 It can take one of the following forms:
 232
 233 =over 5
 234
 235 =item A filename
 236
 237 If the C<$input> parameter is a simple scalar, it is assumed to be a
 238 filename. This file will be opened for reading and the input data
 239 will be read from it.
 240
 241 =item A filehandle
 242
 243 If the C<$input> parameter is a filehandle, the input data will be
 244 read from it.
 245 The string '-' can be used as an alias for standard input.
 246
 247 =item A scalar reference
 248
 249 If C<$input> is a scalar reference, the input data will be read
 250 from C<$$input>.
 251
 252 =item An array reference
 253
 254 If C<$input> is an array reference, each element in the array must be a
 255 filename.
 256
 257 The input data will be read from each file in turn.
 258
 259 The complete array will be walked to ensure that it only
 260 contains valid filenames before any data is uncompressed.
 261
 262
 263
 264 =item An Input FileGlob string
 265
 266 If C<$input> is a string that is delimited by the characters "<" and ">"
 267 C<anyinflate> will assume that it is an I<input fileglob string>. The
 268 input is the list of files that match the fileglob.
 269
 270 If the fileglob does not match any files ...
 271
 272 See L<File::GlobMapper|File::GlobMapper> for more details.
 273
 274
 275 =back
 276
 277 If the C<$input> parameter is any other type, C<undef> will be returned.
 278
 279
 280
 281 =head3 The C<$output> parameter
 282
 283 The parameter C<$output> is used to control the destination of the
 284 uncompressed data. This parameter can take one of these forms.
 285
 286 =over 5
 287
 288 =item A filename
 289
 290 If the C<$output> parameter is a simple scalar, it is assumed to be a
 291 filename.  This file will be opened for writing and the uncompressed
 292 data will be written to it.
 293
 294 =item A filehandle
 295
 296 If the C<$output> parameter is a filehandle, the uncompressed data
 297 will be written to it.
 298 The string '-' can be used as an alias for standard output.
 299
 300
 301 =item A scalar reference
 302
 303 If C<$output> is a scalar reference, the uncompressed data will be
 304 stored in C<$$output>.
 305
 306
 307
 308 =item An Array Reference
 309
 310 If C<$output> is an array reference, the uncompressed data will be
 311 pushed onto the array.
 312
 313 =item An Output FileGlob
 314
 315 If C<$output> is a string that is delimited by the characters "<" and ">"
 316 C<anyinflate> will assume that it is an I<output fileglob string>. The
 317 output is the list of files that match the fileglob.
 318
 319 When C<$output> is an fileglob string, C<$input> must also be a fileglob
 320 string. Anything else is an error.
 321
 322 =back
 323
 324 If the C<$output> parameter is any other type, C<undef> will be returned.
 325
 326
 327
 328 =head2 Notes
 329
 330 When C<$input> maps to multiple files/buffers and C<$output> is a single
 331 file/buffer the uncompressed input files/buffers will all be stored
 332 in C<$output> as a single uncompressed stream.
 333
 334
 335
 336 =head2 Optional Parameters
 337
 338 Unless specified below, the optional parameters for C<anyinflate>,
 339 C<OPTS>, are the same as those used with the OO interface defined in the
 340 L</"Constructor Options"> section below.
 341
 342 =over 5
 343
 344 =item AutoClose =E<gt> 0|1
 345
 346 This option applies to any input or output data streams to
 347 C<anyinflate> that are filehandles.
 348
 349 If C<AutoClose> is specified, and the value is true, it will result in all
 350 input and/or output filehandles being closed once C<anyinflate> has
 351 completed.
 352
 353 This parameter defaults to 0.
 354
 355
 356
 357 =item BinModeOut =E<gt> 0|1
 358
 359 When writing to a file or filehandle, set C<binmode> before writing to the
 360 file.
 361
 362 Defaults to 0.
 363
 364
 365
 366
 367
 368 =item -Append =E<gt> 0|1
 369
 370 TODO
 371
 372 =item -MultiStream =E<gt> 0|1
 373
 374 Creates a new stream after each file.
 375
 376 Defaults to 1.
 377
 378
 379
 380 =back
 381
 382
 383
 384
 385 =head2 Examples
 386
 387 To read the contents of the file C<file1.txt.Compressed> and write the
 388 compressed data to the file C<file1.txt>.
 389
 390     use strict ;
 391     use warnings ;
 392     use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
 393
 394     my $input = "file1.txt.Compressed";
 395     my $output = "file1.txt";
 396     anyinflate $input => $output
 397         or die "anyinflate failed: $AnyInflateError\n";
 398
 399
 400 To read from an existing Perl filehandle, C<$input>, and write the
 401 uncompressed data to a buffer, C<$buffer>.
 402
 403     use strict ;
 404     use warnings ;
 405     use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
 406     use IO::File ;
 407
 408     my $input = new IO::File "<file1.txt.Compressed"
 409         or die "Cannot open 'file1.txt.Compressed': $!\n" ;
 410     my $buffer ;
 411     anyinflate $input => \$buffer
 412         or die "anyinflate failed: $AnyInflateError\n";
 413
 414 To uncompress all files in the directory "/my/home" that match "*.txt.Compressed" and store the compressed data in the same directory
 415
 416     use strict ;
 417     use warnings ;
 418     use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
 419
 420     anyinflate '</my/home/*.txt.Compressed>' => '</my/home/#1.txt>'
 421         or die "anyinflate failed: $AnyInflateError\n";
 422
 423 and if you want to compress each file one at a time, this will do the trick
 424
 425     use strict ;
 426     use warnings ;
 427     use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
 428
 429     for my $input ( glob "/my/home/*.txt.Compressed" )
 430     {
 431         my $output = $input;
 432         $output =~ s/.Compressed// ;
 433         anyinflate $input => $output
 434             or die "Error compressing '$input': $AnyInflateError\n";
 435     }
 436
 437 =head1 OO Interface
 438
 439 =head2 Constructor
 440
 441 The format of the constructor for IO::Uncompress::AnyInflate is shown below
 442
 443
 444     my $z = new IO::Uncompress::AnyInflate $input [OPTS]
 445         or die "IO::Uncompress::AnyInflate failed: $AnyInflateError\n";
 446
 447 Returns an C<IO::Uncompress::AnyInflate> object on success and undef on failure.
 448 The variable C<$AnyInflateError> will contain an error message on failure.
 449
 450 If you are running Perl 5.005 or better the object, C<$z>, returned from
 451 IO::Uncompress::AnyInflate can be used exactly like an L<IO::File|IO::File> filehandle.
 452 This means that all normal input file operations can be carried out with
 453 C<$z>.  For example, to read a line from a compressed file/buffer you can
 454 use either of these forms
 455
 456     $line = $z->getline();
 457     $line = <$z>;
 458
 459 The mandatory parameter C<$input> is used to determine the source of the
 460 compressed data. This parameter can take one of three forms.
 461
 462 =over 5
 463
 464 =item A filename
 465
 466 If the C<$input> parameter is a scalar, it is assumed to be a filename. This
 467 file will be opened for reading and the compressed data will be read from it.
 468
 469 =item A filehandle
 470
 471 If the C<$input> parameter is a filehandle, the compressed data will be
 472 read from it.
 473 The string '-' can be used as an alias for standard input.
 474
 475
 476 =item A scalar reference
 477
 478 If C<$input> is a scalar reference, the compressed data will be read from
 479 C<$$output>.
 480
 481 =back
 482
 483 =head2 Constructor Options
 484
 485
 486 The option names defined below are case insensitive and can be optionally
 487 prefixed by a '-'.  So all of the following are valid
 488
 489     -AutoClose
 490     -autoclose
 491     AUTOCLOSE
 492     autoclose
 493
 494 OPTS is a combination of the following options:
 495
 496 =over 5
 497
 498 =item -AutoClose =E<gt> 0|1
 499
 500 This option is only valid when the C<$input> parameter is a filehandle. If
 501 specified, and the value is true, it will result in the file being closed once
 502 either the C<close> method is called or the IO::Uncompress::AnyInflate object is
 503 destroyed.
 504
 505 This parameter defaults to 0.
 506
 507 =item -MultiStream =E<gt> 0|1
 508
 509
 510
 511 Allows multiple concatenated compressed streams to be treated as a single
 512 compressed stream. Decompression will stop once either the end of the
 513 file/buffer is reached, an error is encountered (premature eof, corrupt
 514 compressed data) or the end of a stream is not immediately followed by the
 515 start of another stream.
 516
 517 This parameter defaults to 0.
 518
 519
 520
 521 =item -Prime =E<gt> $string
 522
 523 This option will uncompress the contents of C<$string> before processing the
 524 input file/buffer.
 525
 526 This option can be useful when the compressed data is embedded in another
 527 file/data structure and it is not possible to work out where the compressed
 528 data begins without having to read the first few bytes. If this is the
 529 case, the uncompression can be I<primed> with these bytes using this
 530 option.
 531
 532 =item -Transparent =E<gt> 0|1
 533
 534 If this option is set and the input file or buffer is not compressed data,
 535 the module will allow reading of it anyway.
 536
 537 This option defaults to 1.
 538
 539 =item -BlockSize =E<gt> $num
 540
 541 When reading the compressed input data, IO::Uncompress::AnyInflate will read it in
 542 blocks of C<$num> bytes.
 543
 544 This option defaults to 4096.
 545
 546 =item -InputLength =E<gt> $size
 547
 548 When present this option will limit the number of compressed bytes read
 549 from the input file/buffer to C<$size>. This option can be used in the
 550 situation where there is useful data directly after the compressed data
 551 stream and you know beforehand the exact length of the compressed data
 552 stream.
 553
 554 This option is mostly used when reading from a filehandle, in which case
 555 the file pointer will be left pointing to the first byte directly after the
 556 compressed data stream.
 557
 558
 559
 560 This option defaults to off.
 561
 562 =item -Append =E<gt> 0|1
 563
 564 This option controls what the C<read> method does with uncompressed data.
 565
 566 If set to 1, all uncompressed data will be appended to the output parameter
 567 of the C<read> method.
 568
 569 If set to 0, the contents of the output parameter of the C<read> method
 570 will be overwritten by the uncompressed data.
 571
 572 Defaults to 0.
 573
 574 =item -Strict =E<gt> 0|1
 575
 576
 577
 578 This option controls whether the extra checks defined below are used when
 579 carrying out the decompression. When Strict is on, the extra tests are
 580 carried out, when Strict is off they are not.
 581
 582 The default for this option is off.
 583
 584
 585 If the input is an RFC 1950 data stream, the following will be checked:
 586
 587
 588
 589
 590 =over 5
 591
 592 =item 1
 593
 594 The ADLER32 checksum field must be present.
 595
 596 =item 2
 597
 598 The value of the ADLER32 field read must match the adler32 value of the
 599 uncompressed data actually contained in the file.
 600
 601 =back
 602
 603
 604
 605 If the input is a gzip (RFC 1952) data stream, the following will be checked:
 606
 607
 608
 609
 610 =over 5
 611
 612 =item 1
 613
 614 If the FHCRC bit is set in the gzip FLG header byte, the CRC16 bytes in the
 615 header must match the crc16 value of the gzip header actually read.
 616
 617 =item 2
 618
 619 If the gzip header contains a name field (FNAME) it consists solely of ISO
 620 8859-1 characters.
 621
 622 =item 3
 623
 624 If the gzip header contains a comment field (FCOMMENT) it consists solely
 625 of ISO 8859-1 characters plus line-feed.
 626
 627 =item 4
 628
 629 If the gzip FEXTRA header field is present it must conform to the sub-field
 630 structure as defined in RFC 1952.
 631
 632 =item 5
 633
 634 The CRC32 and ISIZE trailer fields must be present.
 635
 636 =item 6
 637
 638 The value of the CRC32 field read must match the crc32 value of the
 639 uncompressed data actually contained in the gzip file.
 640
 641 =item 7
 642
 643 The value of the ISIZE fields read must match the length of the
 644 uncompressed data actually read from the file.
 645
 646 =back
 647
 648
 649
 650
 651
 652
 653 =item -ParseExtra =E<gt> 0|1
 654
 655 If the gzip FEXTRA header field is present and this option is set, it will
 656 force the module to check that it conforms to the sub-field structure as
 657 defined in RFC 1952.
 658
 659 If the C<Strict> is on it will automatically enable this option.
 660
 661 Defaults to 0.
 662
 663
 664
 665
 666
 667 =back
 668
 669 =head2 Examples
 670
 671 TODO
 672
 673 =head1 Methods
 674
 675 =head2 read
 676
 677 Usage is
 678
 679     $status = $z->read($buffer)
 680
 681 Reads a block of compressed data (the size the the compressed block is
 682 determined by the C<Buffer> option in the constructor), uncompresses it and
 683 writes any uncompressed data into C<$buffer>. If the C<Append> parameter is
 684 set in the constructor, the uncompressed data will be appended to the
 685 C<$buffer> parameter. Otherwise C<$buffer> will be overwritten.
 686
 687 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
 688 or a negative number on error.
 689
 690 =head2 read
 691
 692 Usage is
 693
 694     $status = $z->read($buffer, $length)
 695     $status = $z->read($buffer, $length, $offset)
 696
 697     $status = read($z, $buffer, $length)
 698     $status = read($z, $buffer, $length, $offset)
 699
 700 Attempt to read C<$length> bytes of uncompressed data into C<$buffer>.
 701
 702 The main difference between this form of the C<read> method and the
 703 previous one, is that this one will attempt to return I<exactly> C<$length>
 704 bytes. The only circumstances that this function will not is if end-of-file
 705 or an IO error is encountered.
 706
 707 Returns the number of uncompressed bytes written to C<$buffer>, zero if eof
 708 or a negative number on error.
 709
 710
 711 =head2 getline
 712
 713 Usage is
 714
 715     $line = $z->getline()
 716     $line = <$z>
 717
 718 Reads a single line.
 719
 720 This method fully supports the use of of the variable C<$/>
 721 (or C<$INPUT_RECORD_SEPARATOR> or C<$RS> when C<English> is in use) to
 722 determine what constitutes an end of line. Both paragraph mode and file
 723 slurp mode are supported.
 724
 725
 726 =head2 getc
 727
 728 Usage is
 729
 730     $char = $z->getc()
 731
 732 Read a single character.
 733
 734 =head2 ungetc
 735
 736 Usage is
 737
 738     $char = $z->ungetc($string)
 739
 740
 741
 742 =head2 inflateSync
 743
 744 Usage is
 745
 746     $status = $z->inflateSync()
 747
 748 TODO
 749
 750
 751 =head2 getHeaderInfo
 752
 753 Usage is
 754
 755     $hdr  = $z->getHeaderInfo();
 756     @hdrs = $z->getHeaderInfo();
 757
 758 This method returns either a hash reference (in scalar context) or a list
 759 or hash references (in array context) that contains information about each
 760 of the header fields in the compressed data stream(s).
 761
 762
 763
 764
 765 =head2 tell
 766
 767 Usage is
 768
 769     $z->tell()
 770     tell $z
 771
 772 Returns the uncompressed file offset.
 773
 774 =head2 eof
 775
 776 Usage is
 777
 778     $z->eof();
 779     eof($z);
 780
 781
 782
 783 Returns true if the end of the compressed input stream has been reached.
 784
 785
 786
 787 =head2 seek
 788
 789     $z->seek($position, $whence);
 790     seek($z, $position, $whence);
 791
 792
 793
 794
 795 Provides a sub-set of the C<seek> functionality, with the restriction
 796 that it is only legal to seek forward in the input file/buffer.
 797 It is a fatal error to attempt to seek backward.
 798
 799
 800
 801 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
 802 SEEK_CUR or SEEK_END.
 803
 804 Returns 1 on success, 0 on failure.
 805
 806 =head2 binmode
 807
 808 Usage is
 809
 810     $z->binmode
 811     binmode $z ;
 812
 813 This is a noop provided for completeness.
 814
 815 =head2 opened
 816
 817     $z->opened()
 818
 819 Returns true if the object currently refers to a opened file/buffer.
 820
 821 =head2 autoflush
 822
 823     my $prev = $z->autoflush()
 824     my $prev = $z->autoflush(EXPR)
 825
 826 If the C<$z> object is associated with a file or a filehandle, this method
 827 returns the current autoflush setting for the underlying filehandle. If
 828 C<EXPR> is present, and is non-zero, it will enable flushing after every
 829 write/print operation.
 830
 831 If C<$z> is associated with a buffer, this method has no effect and always
 832 returns C<undef>.
 833
 834 B<Note> that the special variable C<$|> B<cannot> be used to set or
 835 retrieve the autoflush setting.
 836
 837 =head2 input_line_number
 838
 839     $z->input_line_number()
 840     $z->input_line_number(EXPR)
 841
 842
 843
 844 Returns the current uncompressed line number. If C<EXPR> is present it has
 845 the effect of setting the line number. Note that setting the line number
 846 does not change the current position within the file/buffer being read.
 847
 848 The contents of C<$/> are used to to determine what constitutes a line
 849 terminator.
 850
 851
 852
 853 =head2 fileno
 854
 855     $z->fileno()
 856     fileno($z)
 857
 858 If the C<$z> object is associated with a file or a filehandle, this method
 859 will return the underlying file descriptor.
 860
 861 If the C<$z> object is is associated with a buffer, this method will
 862 return undef.
 863
 864 =head2 close
 865
 866     $z->close() ;
 867     close $z ;
 868
 869
 870
 871 Closes the output file/buffer.
 872
 873
 874
 875 For most versions of Perl this method will be automatically invoked if
 876 the IO::Uncompress::AnyInflate object is destroyed (either explicitly or by the
 877 variable with the reference to the object going out of scope). The
 878 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
 879 these cases, the C<close> method will be called automatically, but
 880 not until global destruction of all live objects when the program is
 881 terminating.
 882
 883 Therefore, if you want your scripts to be able to run on all versions
 884 of Perl, you should call C<close> explicitly and not rely on automatic
 885 closing.
 886
 887 Returns true on success, otherwise 0.
 888
 889 If the C<AutoClose> option has been enabled when the IO::Uncompress::AnyInflate
 890 object was created, and the object is associated with a file, the
 891 underlying file will also be closed.
 892
 893
 894
 895
 896 =head1 Importing
 897
 898 No symbolic constants are required by this IO::Uncompress::AnyInflate at present.
 899
 900 =over 5
 901
 902 =item :all
 903
 904 Imports C<anyinflate> and C<$AnyInflateError>.
 905 Same as doing this
 906
 907     use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
 908
 909 =back
 910
 911 =head1 EXAMPLES
 912
 913
 914
 915
 916 =head1 SEE ALSO
 917
 918 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::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Uncompress::AnyUncompress>
 919
 920 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
 921
 922 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
 923 L<Archive::Tar|Archive::Tar>,
 924 L<IO::Zlib|IO::Zlib>
 925
 926
 927 For RFC 1950, 1951 and 1952 see
 928 F<http://www.faqs.org/rfcs/rfc1950.html>,
 929 F<http://www.faqs.org/rfcs/rfc1951.html> and
 930 F<http://www.faqs.org/rfcs/rfc1952.html>
 931
 932 The I<zlib> compression library was written by Jean-loup Gailly
 933 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
 934
 935 The primary site for the I<zlib> compression library is
 936 F<http://www.zlib.org>.
 937
 938 The primary site for gzip is F<http://www.gzip.org>.
 939
 940
 941
 942
 943
 944
 945
 946 =head1 AUTHOR
 947
 948 The I<IO::Uncompress::AnyInflate> module was written by Paul Marquess,
 949 F<pmqs@cpan.org>.
 950
 951
 952
 953 =head1 MODIFICATION HISTORY
 954
 955 See the Changes file.
 956
 957 =head1 COPYRIGHT AND LICENSE
 958
 959
 960 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
 961
 962 This program is free software; you can redistribute it and/or
 963 modify it under the same terms as Perl itself.
 964