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