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

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