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