1IO::Compress::Gzip(3) User Contributed Perl DocumentationIO::Compress::Gzip(3)
2
6 IO::Compress::Gzip - Write RFC 1952 files/buffers
7
9 use IO::Compress::Gzip qw(gzip $GzipError) ;
10 my $status = gzip $input => $output [,OPTS]
12 or die "gzip failed: $GzipError\n";
13 my $z = IO::Compress::Gzip->new( $output [,OPTS] )
15 or die "gzip failed: $GzipError\n";
16 $z->print($string);
18 $z->printf($format, $string);
19 $z->write($string);
20 $z->syswrite($string [, $length, $offset]);
21 $z->flush();
22 $z->tell();
23 $z->eof();
24 $z->seek($position, $whence);
25 $z->binmode();
26 $z->fileno();
27 $z->opened();
28 $z->autoflush();
29 $z->input_line_number();
30 $z->newStream( [OPTS] );
31 $z->deflateParams();
33 $z->close() ;
35 $GzipError ;
37 # IO::File mode
39 print $z $string;
41 printf $z $format, $string;
42 tell $z
43 eof $z
44 seek $z, $position, $whence
45 binmode $z
46 fileno $z
47 close $z ;
48
50 This module provides a Perl interface that allows writing compressed
51 data to files or buffer as defined in RFC 1952.
52 All the gzip headers defined in RFC 1952 can be created using this
54 module.
55 For reading RFC 1952 files/buffers, see the companion module
57 IO::Uncompress::Gunzip.
58
60 A top-level function, "gzip", is provided to carry out "one-shot"
61 compression between buffers and/or files. For finer control over the
62 compression process, see the "OO Interface" section.
63 use IO::Compress::Gzip qw(gzip $GzipError) ;
65 gzip $input_filename_or_reference => $output_filename_or_reference [,OPTS]
67 or die "gzip failed: $GzipError\n";
68 The functional interface needs Perl5.005 or better.
70 gzip $input_filename_or_reference => $output_filename_or_reference [, OPTS]
72 "gzip" expects at least two parameters, $input_filename_or_reference
73 and $output_filename_or_reference and zero or more optional parameters
74 (see "Optional Parameters")
75 The $input_filename_or_reference parameter
77 The parameter, $input_filename_or_reference, is used to define the
79 source of the uncompressed data.
80 It can take one of the following forms:
82 A filename
84 If the $input_filename_or_reference parameter is a simple scalar,
85 it is assumed to be a filename. This file will be opened for
86 reading and the input data will be read from it.
87 A filehandle
89 If the $input_filename_or_reference parameter is a filehandle, the
90 input data will be read from it. The string '-' can be used as an
91 alias for standard input.
92 A scalar reference
94 If $input_filename_or_reference is a scalar reference, the input
95 data will be read from $$input_filename_or_reference.
96 An array reference
98 If $input_filename_or_reference is an array reference, each
99 element in the array must be a filename.
100 The input data will be read from each file in turn.
102 The complete array will be walked to ensure that it only contains
104 valid filenames before any data is compressed.
105 An Input FileGlob string
107 If $input_filename_or_reference is a string that is delimited by
108 the characters "<" and ">" "gzip" will assume that it is an input
109 fileglob string. The input is the list of files that match the
110 fileglob.
111 See File::GlobMapper for more details.
113 If the $input_filename_or_reference parameter is any other type,
115 "undef" will be returned.
116 In addition, if $input_filename_or_reference is a simple filename, the
118 default values for the "Name" and "Time" options will be sourced from
119 that file.
120 If you do not want to use these defaults they can be overridden by
122 explicitly setting the "Name" and "Time" options or by setting the
123 "Minimal" parameter.
124 The $output_filename_or_reference parameter
126 The parameter $output_filename_or_reference is used to control the
128 destination of the compressed data. This parameter can take one of
129 these forms.
130 A filename
132 If the $output_filename_or_reference parameter is a simple scalar,
133 it is assumed to be a filename. This file will be opened for
134 writing and the compressed data will be written to it.
135 A filehandle
137 If the $output_filename_or_reference parameter is a filehandle,
138 the compressed data will be written to it. The string '-' can be
139 used as an alias for standard output.
140 A scalar reference
142 If $output_filename_or_reference is a scalar reference, the
143 compressed data will be stored in $$output_filename_or_reference.
144 An Array Reference
146 If $output_filename_or_reference is an array reference, the
147 compressed data will be pushed onto the array.
148 An Output FileGlob
150 If $output_filename_or_reference is a string that is delimited by
151 the characters "<" and ">" "gzip" will assume that it is an output
152 fileglob string. The output is the list of files that match the
153 fileglob.
154 When $output_filename_or_reference is an fileglob string,
156 $input_filename_or_reference must also be a fileglob string.
157 Anything else is an error.
158 See File::GlobMapper for more details.
160 If the $output_filename_or_reference parameter is any other type,
162 "undef" will be returned.
163 Notes
165 When $input_filename_or_reference maps to multiple files/buffers and
166 $output_filename_or_reference is a single file/buffer the input
167 files/buffers will be stored in $output_filename_or_reference as a
168 concatenated series of compressed data streams.
169 Optional Parameters
171 The optional parameters for the one-shot function "gzip" are (for the
172 most part) identical to those used with the OO interface defined in the
173 "Constructor Options" section. The exceptions are listed below
174 "AutoClose => 0|1"
176 This option applies to any input or output data streams to "gzip"
177 that are filehandles.
178 If "AutoClose" is specified, and the value is true, it will result
180 in all input and/or output filehandles being closed once "gzip"
181 has completed.
182 This parameter defaults to 0.
184 "BinModeIn => 0|1"
186 This option is now a no-op. All files will be read in binmode.
187 "Append => 0|1"
189 The behaviour of this option is dependent on the type of output
190 data stream.
191 • A Buffer
193 If "Append" is enabled, all compressed data will be append to
195 the end of the output buffer. Otherwise the output buffer
196 will be cleared before any compressed data is written to it.
197 • A Filename
199 If "Append" is enabled, the file will be opened in append
201 mode. Otherwise the contents of the file, if any, will be
202 truncated before any compressed data is written to it.
203 • A Filehandle
205 If "Append" is enabled, the filehandle will be positioned to
207 the end of the file via a call to "seek" before any
208 compressed data is written to it. Otherwise the file pointer
209 will not be moved.
210 When "Append" is specified, and set to true, it will append all
212 compressed data to the output data stream.
213 So when the output is a filehandle it will carry out a seek to the
215 eof before writing any compressed data. If the output is a
216 filename, it will be opened for appending. If the output is a
217 buffer, all compressed data will be appended to the existing
218 buffer.
219 Conversely when "Append" is not specified, or it is present and is
221 set to false, it will operate as follows.
222 When the output is a filename, it will truncate the contents of
224 the file before writing any compressed data. If the output is a
225 filehandle its position will not be changed. If the output is a
226 buffer, it will be wiped before any compressed data is output.
227 Defaults to 0.
229 Examples
231 Here are a few example that show the capabilities of the module.
232 Streaming
234 This very simple command line example demonstrates the streaming
236 capabilities of the module. The code reads data from STDIN, compresses
237 it, and writes the compressed data to STDOUT.
238 $ echo hello world | perl -MIO::Compress::Gzip=gzip -e 'gzip \*STDIN => \*STDOUT' >output.gz
240 The special filename "-" can be used as a standin for both "\*STDIN"
242 and "\*STDOUT", so the above can be rewritten as
243 $ echo hello world | perl -MIO::Compress::Gzip=gzip -e 'gzip "-" => "-"' >output.gz
245 Compressing a file from the filesystem
247 To read the contents of the file "file1.txt" and write the compressed
249 data to the file "file1.txt.gz".
250 use strict ;
252 use warnings ;
253 use IO::Compress::Gzip qw(gzip $GzipError) ;
254 my $input = "file1.txt";
256 gzip $input => "$input.gz"
257 or die "gzip failed: $GzipError\n";
258 Reading from a Filehandle and writing to an in-memory buffer
260 To read from an existing Perl filehandle, $input, and write the
262 compressed data to a buffer, $buffer.
263 use strict ;
265 use warnings ;
266 use IO::Compress::Gzip qw(gzip $GzipError) ;
267 use IO::File ;
268 my $input = IO::File->new( "<file1.txt" )
270 or die "Cannot open 'file1.txt': $!\n" ;
271 my $buffer ;
272 gzip $input => \$buffer
273 or die "gzip failed: $GzipError\n";
274 Compressing multiple files
276 To compress all files in the directory "/my/home" that match "*.txt"
278 and store the compressed data in the same directory
279 use strict ;
281 use warnings ;
282 use IO::Compress::Gzip qw(gzip $GzipError) ;
283 gzip '</my/home/*.txt>' => '<*.gz>'
285 or die "gzip failed: $GzipError\n";
286 and if you want to compress each file one at a time, this will do the
288 trick
289 use strict ;
291 use warnings ;
292 use IO::Compress::Gzip qw(gzip $GzipError) ;
293 for my $input ( glob "/my/home/*.txt" )
295 {
296 my $output = "$input.gz" ;
297 gzip $input => $output
298 or die "Error compressing '$input': $GzipError\n";
299 }
300
302 Constructor
303 The format of the constructor for "IO::Compress::Gzip" is shown below
304 my $z = IO::Compress::Gzip->new( $output [,OPTS] )
306 or die "IO::Compress::Gzip failed: $GzipError\n";
307 It returns an "IO::Compress::Gzip" object on success and undef on
309 failure. The variable $GzipError will contain an error message on
310 failure.
311 If you are running Perl 5.005 or better the object, $z, returned from
313 IO::Compress::Gzip can be used exactly like an IO::File filehandle.
314 This means that all normal output file operations can be carried out
315 with $z. For example, to write to a compressed file/buffer you can use
316 either of these forms
317 $z->print("hello world\n");
319 print $z "hello world\n";
320 The mandatory parameter $output is used to control the destination of
322 the compressed data. This parameter can take one of these forms.
323 A filename
325 If the $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 A filehandle
330 If the $output parameter is a filehandle, the compressed data will
331 be written to it. The string '-' can be used as an alias for
332 standard output.
333 A scalar reference
335 If $output is a scalar reference, the compressed data will be
336 stored in $$output.
337 If the $output parameter is any other type, "IO::Compress::Gzip"::new
339 will return undef.
340 Constructor Options
342 "OPTS" is any combination of zero or more the following options:
343 "AutoClose => 0|1"
345 This option is only valid when the $output parameter is a
346 filehandle. If specified, and the value is true, it will result in
347 the $output being closed once either the "close" method is called
348 or the "IO::Compress::Gzip" object is destroyed.
349 This parameter defaults to 0.
351 "Append => 0|1"
353 Opens $output in append mode.
354 The behaviour of this option is dependent on the type of $output.
356 • A Buffer
358 If $output is a buffer and "Append" is enabled, all
360 compressed data will be append to the end of $output.
361 Otherwise $output will be cleared before any data is written
362 to it.
363 • A Filename
365 If $output is a filename and "Append" is enabled, the file
367 will be opened in append mode. Otherwise the contents of the
368 file, if any, will be truncated before any compressed data is
369 written to it.
370 • A Filehandle
372 If $output is a filehandle, the file pointer will be
374 positioned to the end of the file via a call to "seek" before
375 any compressed data is written to it. Otherwise the file
376 pointer will not be moved.
377 This parameter defaults to 0.
379 "Merge => 0|1"
381 This option is used to compress input data and append it to an
382 existing compressed data stream in $output. The end result is a
383 single compressed data stream stored in $output.
384 It is a fatal error to attempt to use this option when $output is
386 not an RFC 1952 data stream.
387 There are a number of other limitations with the "Merge" option:
389 1. This module needs to have been built with zlib 1.2.1 or
391 better to work. A fatal error will be thrown if "Merge" is
392 used with an older version of zlib.
393 2. If $output is a file or a filehandle, it must be seekable.
395 This parameter defaults to 0.
397 -Level
399 Defines the compression level used by zlib. The value should
400 either be a number between 0 and 9 (0 means no compression and 9
401 is maximum compression), or one of the symbolic constants defined
402 below.
403 Z_NO_COMPRESSION
405 Z_BEST_SPEED
406 Z_BEST_COMPRESSION
407 Z_DEFAULT_COMPRESSION
408 The default is Z_DEFAULT_COMPRESSION.
410 Note, these constants are not imported by "IO::Compress::Gzip" by
412 default.
413 use IO::Compress::Gzip qw(:strategy);
415 use IO::Compress::Gzip qw(:constants);
416 use IO::Compress::Gzip qw(:all);
417 -Strategy
419 Defines the strategy used to tune the compression. Use one of the
420 symbolic constants defined below.
421 Z_FILTERED
423 Z_HUFFMAN_ONLY
424 Z_RLE
425 Z_FIXED
426 Z_DEFAULT_STRATEGY
427 The default is Z_DEFAULT_STRATEGY.
429 "Minimal => 0|1"
431 If specified, this option will force the creation of the smallest
432 possible compliant gzip header (which is exactly 10 bytes long) as
433 defined in RFC 1952.
434 See the section titled "Compliance" in RFC 1952 for a definition
436 of the values used for the fields in the gzip header.
437 All other parameters that control the content of the gzip header
439 will be ignored if this parameter is set to 1.
440 This parameter defaults to 0.
442 "Comment => $comment"
444 Stores the contents of $comment in the COMMENT field in the gzip
445 header. By default, no comment field is written to the gzip file.
446 If the "-Strict" option is enabled, the comment can only consist
448 of ISO 8859-1 characters plus line feed.
449 If the "-Strict" option is disabled, the comment field can contain
451 any character except NULL. If any null characters are present, the
452 field will be truncated at the first NULL.
453 "Name => $string"
455 Stores the contents of $string in the gzip NAME header field. If
456 "Name" is not specified, no gzip NAME field will be created.
457 If the "-Strict" option is enabled, $string can only consist of
459 ISO 8859-1 characters.
460 If "-Strict" is disabled, then $string can contain any character
462 except NULL. If any null characters are present, the field will be
463 truncated at the first NULL.
464 "Time => $number"
466 Sets the MTIME field in the gzip header to $number.
467 This field defaults to the time the "IO::Compress::Gzip" object
469 was created if this option is not specified.
470 "TextFlag => 0|1"
472 This parameter controls the setting of the FLG.FTEXT bit in the
473 gzip header. It is used to signal that the data stored in the gzip
474 file/buffer is probably text.
475 The default is 0.
477 "HeaderCRC => 0|1"
479 When true this parameter will set the FLG.FHCRC bit to 1 in the
480 gzip header and set the CRC16 header field to the CRC of the
481 complete gzip header except the CRC16 field itself.
482 Note that gzip files created with the "HeaderCRC" flag set to 1
484 cannot be read by most, if not all, of the standard gunzip
485 utilities, most notably gzip version 1.2.4. You should therefore
486 avoid using this option if you want to maximize the portability of
487 your gzip files.
488 This parameter defaults to 0.
490 "OS_Code => $value"
492 Stores $value in the gzip OS header field. A number between 0 and
493 255 is valid.
494 If not specified, this parameter defaults to the OS code of the
496 Operating System this module was built on. The value 3 is used as
497 a catch-all for all Unix variants and unknown Operating Systems.
498 "ExtraField => $data"
500 This parameter allows additional metadata to be stored in the
501 ExtraField in the gzip header. An RFC 1952 compliant ExtraField
502 consists of zero or more subfields. Each subfield consists of a
503 two byte header followed by the subfield data.
504 The list of subfields can be supplied in any of the following
506 formats
507 -ExtraField => [$id1, $data1,
509 $id2, $data2,
510 ...
511 ]
512 -ExtraField => [ [$id1 => $data1],
513 [$id2 => $data2],
514 ...
515 ]
516 -ExtraField => { $id1 => $data1,
517 $id2 => $data2,
518 ...
519 }
520 Where $id1, $id2 are two byte subfield ID's. The second byte of
522 the ID cannot be 0, unless the "Strict" option has been disabled.
523 If you use the hash syntax, you have no control over the order in
525 which the ExtraSubFields are stored, plus you cannot have
526 SubFields with duplicate ID.
527 Alternatively the list of subfields can by supplied as a scalar,
529 thus
530 -ExtraField => $rawdata
532 If you use the raw format, and the "Strict" option is enabled,
534 "IO::Compress::Gzip" will check that $rawdata consists of zero or
535 more conformant sub-fields. When "Strict" is disabled, $rawdata
536 can consist of any arbitrary byte stream.
537 The maximum size of the Extra Field 65535 bytes.
539 "ExtraFlags => $value"
541 Sets the XFL byte in the gzip header to $value.
542 If this option is not present, the value stored in XFL field will
544 be determined by the setting of the "Level" option.
545 If "Level => Z_BEST_SPEED" has been specified then XFL is set to
547 2. If "Level => Z_BEST_COMPRESSION" has been specified then XFL
548 is set to 4. Otherwise XFL is set to 0.
549 "Strict => 0|1"
551 "Strict" will optionally police the values supplied with other
552 options to ensure they are compliant with RFC1952.
553 This option is enabled by default.
555 If "Strict" is enabled the following behaviour will be policed:
557 • The value supplied with the "Name" option can only contain
559 ISO 8859-1 characters.
560 • The value supplied with the "Comment" option can only contain
562 ISO 8859-1 characters plus line-feed.
563 • The values supplied with the "-Name" and "-Comment" options
565 cannot contain multiple embedded nulls.
566 • If an "ExtraField" option is specified and it is a simple
568 scalar, it must conform to the sub-field structure as defined
569 in RFC 1952.
570 • If an "ExtraField" option is specified the second byte of the
572 ID will be checked in each subfield to ensure that it does
573 not contain the reserved value 0x00.
574 When "Strict" is disabled the following behaviour will be policed:
576 • The value supplied with "-Name" option can contain any
578 character except NULL.
579 • The value supplied with "-Comment" option can contain any
581 character except NULL.
582 • The values supplied with the "-Name" and "-Comment" options
584 can contain multiple embedded nulls. The string written to
585 the gzip header will consist of the characters up to, but not
586 including, the first embedded NULL.
587 • If an "ExtraField" option is specified and it is a simple
589 scalar, the structure will not be checked. The only error is
590 if the length is too big.
591 • The ID header in an "ExtraField" sub-field can consist of any
593 two bytes.
594 Examples
596 TODO
597
599 print
600 Usage is
601 $z->print($data)
603 print $z $data
604 Compresses and outputs the contents of the $data parameter. This has
606 the same behaviour as the "print" built-in.
607 Returns true if successful.
609 printf
611 Usage is
612 $z->printf($format, $data)
614 printf $z $format, $data
615 Compresses and outputs the contents of the $data parameter.
617 Returns true if successful.
619 syswrite
621 Usage is
622 $z->syswrite $data
624 $z->syswrite $data, $length
625 $z->syswrite $data, $length, $offset
626 Compresses and outputs the contents of the $data parameter.
628 Returns the number of uncompressed bytes written, or "undef" if
630 unsuccessful.
631 write
633 Usage is
634 $z->write $data
636 $z->write $data, $length
637 $z->write $data, $length, $offset
638 Compresses and outputs the contents of the $data parameter.
640 Returns the number of uncompressed bytes written, or "undef" if
642 unsuccessful.
643 flush
645 Usage is
646 $z->flush;
648 $z->flush($flush_type);
649 Flushes any pending compressed data to the output file/buffer.
651 This method takes an optional parameter, $flush_type, that controls how
653 the flushing will be carried out. By default the $flush_type used is
654 "Z_FINISH". Other valid values for $flush_type are "Z_NO_FLUSH",
655 "Z_SYNC_FLUSH", "Z_FULL_FLUSH" and "Z_BLOCK". It is strongly
656 recommended that you only set the "flush_type" parameter if you fully
657 understand the implications of what it does - overuse of "flush" can
658 seriously degrade the level of compression achieved. See the "zlib"
659 documentation for details.
660 Returns true on success.
662 tell
664 Usage is
665 $z->tell()
667 tell $z
668 Returns the uncompressed file offset.
670 eof
672 Usage is
673 $z->eof();
675 eof($z);
676 Returns true if the "close" method has been called.
678 seek
680 $z->seek($position, $whence);
681 seek($z, $position, $whence);
682 Provides a sub-set of the "seek" functionality, with the restriction
684 that it is only legal to seek forward in the output file/buffer. It is
685 a fatal error to attempt to seek backward.
686 Empty parts of the file/buffer will have NULL (0x00) bytes written to
688 them.
689 The $whence parameter takes one the usual values, namely SEEK_SET,
691 SEEK_CUR or SEEK_END.
692 Returns 1 on success, 0 on failure.
694 binmode
696 Usage is
697 $z->binmode
699 binmode $z ;
700 This is a noop provided for completeness.
702 opened
704 $z->opened()
705 Returns true if the object currently refers to a opened file/buffer.
707 autoflush
709 my $prev = $z->autoflush()
710 my $prev = $z->autoflush(EXPR)
711 If the $z object is associated with a file or a filehandle, this method
713 returns the current autoflush setting for the underlying filehandle. If
714 "EXPR" is present, and is non-zero, it will enable flushing after every
715 write/print operation.
716 If $z is associated with a buffer, this method has no effect and always
718 returns "undef".
719 Note that the special variable $| cannot be used to set or retrieve the
721 autoflush setting.
722 input_line_number
724 $z->input_line_number()
725 $z->input_line_number(EXPR)
726 This method always returns "undef" when compressing.
728 fileno
730 $z->fileno()
731 fileno($z)
732 If the $z object is associated with a file or a filehandle, "fileno"
734 will return the underlying file descriptor. Once the "close" method is
735 called "fileno" will return "undef".
736 If the $z object is associated with a buffer, this method will return
738 "undef".
739 close
741 $z->close() ;
742 close $z ;
743 Flushes any pending compressed data and then closes the output
745 file/buffer.
746 For most versions of Perl this method will be automatically invoked if
748 the IO::Compress::Gzip object is destroyed (either explicitly or by the
749 variable with the reference to the object going out of scope). The
750 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In these
751 cases, the "close" method will be called automatically, but not until
752 global destruction of all live objects when the program is terminating.
753 Therefore, if you want your scripts to be able to run on all versions
755 of Perl, you should call "close" explicitly and not rely on automatic
756 closing.
757 Returns true on success, otherwise 0.
759 If the "AutoClose" option has been enabled when the IO::Compress::Gzip
761 object was created, and the object is associated with a file, the
762 underlying file will also be closed.
763 newStream([OPTS])
765 Usage is
766 $z->newStream( [OPTS] )
768 Closes the current compressed data stream and starts a new one.
770 OPTS consists of any of the options that are available when creating
772 the $z object.
773 See the "Constructor Options" section for more details.
775 deflateParams
777 Usage is
778 $z->deflateParams
780 TODO
782
784 A number of symbolic constants are required by some methods in
785 "IO::Compress::Gzip". None are imported by default.
786 :all Imports "gzip", $GzipError and all symbolic constants that can be
788 used by "IO::Compress::Gzip". Same as doing this
789 use IO::Compress::Gzip qw(gzip $GzipError :constants) ;
791 :constants
793 Import all symbolic constants. Same as doing this
794 use IO::Compress::Gzip qw(:flush :level :strategy) ;
796 :flush
798 These symbolic constants are used by the "flush" method.
799 Z_NO_FLUSH
801 Z_PARTIAL_FLUSH
802 Z_SYNC_FLUSH
803 Z_FULL_FLUSH
804 Z_FINISH
805 Z_BLOCK
806 :level
808 These symbolic constants are used by the "Level" option in the
809 constructor.
810 Z_NO_COMPRESSION
812 Z_BEST_SPEED
813 Z_BEST_COMPRESSION
814 Z_DEFAULT_COMPRESSION
815 :strategy
817 These symbolic constants are used by the "Strategy" option in the
818 constructor.
819 Z_FILTERED
821 Z_HUFFMAN_ONLY
822 Z_RLE
823 Z_FIXED
824 Z_DEFAULT_STRATEGY
825
827 Apache::GZip Revisited
828 See IO::Compress::FAQ
829 Working with Net::FTP
831 See IO::Compress::FAQ
832
834 General feedback/questions/bug reports should be sent to
835 <https://github.com/pmqs/IO-Copress/issues> (preferred) or
836 <https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Copress>.
837
839 Compress::Zlib, IO::Uncompress::Gunzip, IO::Compress::Deflate,
840 IO::Uncompress::Inflate, IO::Compress::RawDeflate,
841 IO::Uncompress::RawInflate, IO::Compress::Bzip2,
842 IO::Uncompress::Bunzip2, IO::Compress::Lzma, IO::Uncompress::UnLzma,
843 IO::Compress::Xz, IO::Uncompress::UnXz, IO::Compress::Lzip,
844 IO::Uncompress::UnLzip, IO::Compress::Lzop, IO::Uncompress::UnLzop,
845 IO::Compress::Lzf, IO::Uncompress::UnLzf, IO::Compress::Zstd,
846 IO::Uncompress::UnZstd, IO::Uncompress::AnyInflate,
847 IO::Uncompress::AnyUncompress
848 IO::Compress::FAQ
850 File::GlobMapper, Archive::Zip, Archive::Tar, IO::Zlib
852 For RFC 1950, 1951 and 1952 see
854 <http://www.faqs.org/rfcs/rfc1950.html>,
855 <http://www.faqs.org/rfcs/rfc1951.html> and
856 <http://www.faqs.org/rfcs/rfc1952.html>
857 The zlib compression library was written by Jean-loup Gailly
859 "gzip@prep.ai.mit.edu" and Mark Adler "madler@alumni.caltech.edu".
860 The primary site for the zlib compression library is
862 <http://www.zlib.org>.
863 The primary site for gzip is <http://www.gzip.org>.
865
867 This module was written by Paul Marquess, "pmqs@cpan.org".
868
870 See the Changes file.
871
873 Copyright (c) 2005-2021 Paul Marquess. All rights reserved.
874 This program is free software; you can redistribute it and/or modify it
876 under the same terms as Perl itself.
877perl v5.34.0 2022-01-21 IO::Compress::Gzip(3)