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 = new IO::Compress::Gzip $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.
74 The $input_filename_or_reference parameter
76 The parameter, $input_filename_or_reference, is used to define the
78 source of the uncompressed data.
79 It can take one of the following forms:
81 A filename
83 If the <$input_filename_or_reference> parameter is a simple
84 scalar, it is assumed to be a filename. This file will be opened
85 for reading and the input data will be read from it.
86 A filehandle
88 If the $input_filename_or_reference parameter is a filehandle, the
89 input data will be read from it. The string '-' can be used as an
90 alias for standard input.
91 A scalar reference
93 If $input_filename_or_reference is a scalar reference, the input
94 data will be read from $$input_filename_or_reference.
95 An array reference
97 If $input_filename_or_reference is an array reference, each
98 element in the array must be a filename.
99 The input data will be read from each file in turn.
101 The complete array will be walked to ensure that it only contains
103 valid filenames before any data is compressed.
104 An Input FileGlob string
106 If $input_filename_or_reference is a string that is delimited by
107 the characters "<" and ">" "gzip" will assume that it is an input
108 fileglob string. The input is the list of files that match the
109 fileglob.
110 See File::GlobMapper for more details.
112 If the $input_filename_or_reference parameter is any other type,
114 "undef" will be returned.
115 In addition, if $input_filename_or_reference is a simple filename, the
117 default values for the "Name" and "Time" options will be sourced from
118 that file.
119 If you do not want to use these defaults they can be overridden by
121 explicitly setting the "Name" and "Time" options or by setting the
122 "Minimal" parameter.
123 The $output_filename_or_reference parameter
125 The parameter $output_filename_or_reference is used to control the
127 destination of the compressed data. This parameter can take one of
128 these forms.
129 A filename
131 If the $output_filename_or_reference parameter is a simple scalar,
132 it is assumed to be a filename. This file will be opened for
133 writing and the compressed data will be written to it.
134 A filehandle
136 If the $output_filename_or_reference parameter is a filehandle,
137 the compressed data will be written to it. The string '-' can be
138 used as an alias for standard output.
139 A scalar reference
141 If $output_filename_or_reference is a scalar reference, the
142 compressed data will be stored in $$output_filename_or_reference.
143 An Array Reference
145 If $output_filename_or_reference is an array reference, the
146 compressed data will be pushed onto the array.
147 An Output FileGlob
149 If $output_filename_or_reference is a string that is delimited by
150 the characters "<" and ">" "gzip" will assume that it is an output
151 fileglob string. The output is the list of files that match the
152 fileglob.
153 When $output_filename_or_reference is an fileglob string,
155 $input_filename_or_reference must also be a fileglob string.
156 Anything else is an error.
157 See File::GlobMapper for more details.
159 If the $output_filename_or_reference parameter is any other type,
161 "undef" will be returned.
162 Notes
164 When $input_filename_or_reference maps to multiple files/buffers and
165 $output_filename_or_reference is a single file/buffer the input
166 files/buffers will be stored in $output_filename_or_reference as a
167 concatenated series of compressed data streams.
168 Optional Parameters
170 Unless specified below, the optional parameters for "gzip", "OPTS", are
171 the same as those used with the OO interface defined in the
172 "Constructor Options" section below.
173 "AutoClose => 0|1"
175 This option applies to any input or output data streams to "gzip"
176 that are filehandles.
177 If "AutoClose" is specified, and the value is true, it will result
179 in all input and/or output filehandles being closed once "gzip"
180 has completed.
181 This parameter defaults to 0.
183 "BinModeIn => 0|1"
185 When reading from a file or filehandle, set "binmode" before
186 reading.
187 Defaults to 0.
189 "Append => 0|1"
191 The behaviour of this option is dependent on the type of output
192 data stream.
193 · A Buffer
195 If "Append" is enabled, all compressed data will be append to
197 the end of the output buffer. Otherwise the output buffer
198 will be cleared before any compressed data is written to it.
199 · A Filename
201 If "Append" is enabled, the file will be opened in append
203 mode. Otherwise the contents of the file, if any, will be
204 truncated before any compressed data is written to it.
205 · A Filehandle
207 If "Append" is enabled, the filehandle will be positioned to
209 the end of the file via a call to "seek" before any
210 compressed data is written to it. Otherwise the file pointer
211 will not be moved.
212 When "Append" is specified, and set to true, it will append all
214 compressed data to the output data stream.
215 So when the output is a filehandle it will carry out a seek to the
217 eof before writing any compressed data. If the output is a
218 filename, it will be opened for appending. If the output is a
219 buffer, all compressed data will be appended to the existing
220 buffer.
221 Conversely when "Append" is not specified, or it is present and is
223 set to false, it will operate as follows.
224 When the output is a filename, it will truncate the contents of
226 the file before writing any compressed data. If the output is a
227 filehandle its position will not be changed. If the output is a
228 buffer, it will be wiped before any compressed data is output.
229 Defaults to 0.
231 Examples
233 To read the contents of the file "file1.txt" and write the compressed
234 data to the file "file1.txt.gz".
235 use strict ;
237 use warnings ;
238 use IO::Compress::Gzip qw(gzip $GzipError) ;
239 my $input = "file1.txt";
241 gzip $input => "$input.gz"
242 or die "gzip failed: $GzipError\n";
243 To read from an existing Perl filehandle, $input, and write the
245 compressed data to a buffer, $buffer.
246 use strict ;
248 use warnings ;
249 use IO::Compress::Gzip qw(gzip $GzipError) ;
250 use IO::File ;
251 my $input = new IO::File "<file1.txt"
253 or die "Cannot open 'file1.txt': $!\n" ;
254 my $buffer ;
255 gzip $input => \$buffer
256 or die "gzip failed: $GzipError\n";
257 To compress all files in the directory "/my/home" that match "*.txt"
259 and store the compressed data in the same directory
260 use strict ;
262 use warnings ;
263 use IO::Compress::Gzip qw(gzip $GzipError) ;
264 gzip '</my/home/*.txt>' => '<*.gz>'
266 or die "gzip failed: $GzipError\n";
267 and if you want to compress each file one at a time, this will do the
269 trick
270 use strict ;
272 use warnings ;
273 use IO::Compress::Gzip qw(gzip $GzipError) ;
274 for my $input ( glob "/my/home/*.txt" )
276 {
277 my $output = "$input.gz" ;
278 gzip $input => $output
279 or die "Error compressing '$input': $GzipError\n";
280 }
281
283 Constructor
284 The format of the constructor for "IO::Compress::Gzip" is shown below
285 my $z = new IO::Compress::Gzip $output [,OPTS]
287 or die "IO::Compress::Gzip failed: $GzipError\n";
288 It returns an "IO::Compress::Gzip" object on success and undef on
290 failure. The variable $GzipError will contain an error message on
291 failure.
292 If you are running Perl 5.005 or better the object, $z, returned from
294 IO::Compress::Gzip can be used exactly like an IO::File filehandle.
295 This means that all normal output file operations can be carried out
296 with $z. For example, to write to a compressed file/buffer you can use
297 either of these forms
298 $z->print("hello world\n");
300 print $z "hello world\n";
301 The mandatory parameter $output is used to control the destination of
303 the compressed data. This parameter can take one of these forms.
304 A filename
306 If the $output parameter is a simple scalar, it is assumed to be a
307 filename. This file will be opened for writing and the compressed
308 data will be written to it.
309 A filehandle
311 If the $output parameter is a filehandle, the compressed data will
312 be written to it. The string '-' can be used as an alias for
313 standard output.
314 A scalar reference
316 If $output is a scalar reference, the compressed data will be
317 stored in $$output.
318 If the $output parameter is any other type, "IO::Compress::Gzip"::new
320 will return undef.
321 Constructor Options
323 "OPTS" is any combination of the following options:
324 "AutoClose => 0|1"
326 This option is only valid when the $output parameter is a
327 filehandle. If specified, and the value is true, it will result in
328 the $output being closed once either the "close" method is called
329 or the "IO::Compress::Gzip" object is destroyed.
330 This parameter defaults to 0.
332 "Append => 0|1"
334 Opens $output in append mode.
335 The behaviour of this option is dependent on the type of $output.
337 · A Buffer
339 If $output is a buffer and "Append" is enabled, all
341 compressed data will be append to the end of $output.
342 Otherwise $output will be cleared before any data is written
343 to it.
344 · A Filename
346 If $output is a filename and "Append" is enabled, the file
348 will be opened in append mode. Otherwise the contents of the
349 file, if any, will be truncated before any compressed data is
350 written to it.
351 · A Filehandle
353 If $output is a filehandle, the file pointer will be
355 positioned to the end of the file via a call to "seek" before
356 any compressed data is written to it. Otherwise the file
357 pointer will not be moved.
358 This parameter defaults to 0.
360 "Merge => 0|1"
362 This option is used to compress input data and append it to an
363 existing compressed data stream in $output. The end result is a
364 single compressed data stream stored in $output.
365 It is a fatal error to attempt to use this option when $output is
367 not an RFC 1952 data stream.
368 There are a number of other limitations with the "Merge" option:
370 1. This module needs to have been built with zlib 1.2.1 or
372 better to work. A fatal error will be thrown if "Merge" is
373 used with an older version of zlib.
374 2. If $output is a file or a filehandle, it must be seekable.
376 This parameter defaults to 0.
378 -Level
380 Defines the compression level used by zlib. The value should
381 either be a number between 0 and 9 (0 means no compression and 9
382 is maximum compression), or one of the symbolic constants defined
383 below.
384 Z_NO_COMPRESSION
386 Z_BEST_SPEED
387 Z_BEST_COMPRESSION
388 Z_DEFAULT_COMPRESSION
389 The default is Z_DEFAULT_COMPRESSION.
391 Note, these constants are not imported by "IO::Compress::Gzip" by
393 default.
394 use IO::Compress::Gzip qw(:strategy);
396 use IO::Compress::Gzip qw(:constants);
397 use IO::Compress::Gzip qw(:all);
398 -Strategy
400 Defines the strategy used to tune the compression. Use one of the
401 symbolic constants defined below.
402 Z_FILTERED
404 Z_HUFFMAN_ONLY
405 Z_RLE
406 Z_FIXED
407 Z_DEFAULT_STRATEGY
408 The default is Z_DEFAULT_STRATEGY.
410 "Minimal => 0|1"
412 If specified, this option will force the creation of the smallest
413 possible compliant gzip header (which is exactly 10 bytes long) as
414 defined in RFC 1952.
415 See the section titled "Compliance" in RFC 1952 for a definition
417 of the values used for the fields in the gzip header.
418 All other parameters that control the content of the gzip header
420 will be ignored if this parameter is set to 1.
421 This parameter defaults to 0.
423 "Comment => $comment"
425 Stores the contents of $comment in the COMMENT field in the gzip
426 header. By default, no comment field is written to the gzip file.
427 If the "-Strict" option is enabled, the comment can only consist
429 of ISO 8859-1 characters plus line feed.
430 If the "-Strict" option is disabled, the comment field can contain
432 any character except NULL. If any null characters are present, the
433 field will be truncated at the first NULL.
434 "Name => $string"
436 Stores the contents of $string in the gzip NAME header field. If
437 "Name" is not specified, no gzip NAME field will be created.
438 If the "-Strict" option is enabled, $string can only consist of
440 ISO 8859-1 characters.
441 If "-Strict" is disabled, then $string can contain any character
443 except NULL. If any null characters are present, the field will be
444 truncated at the first NULL.
445 "Time => $number"
447 Sets the MTIME field in the gzip header to $number.
448 This field defaults to the time the "IO::Compress::Gzip" object
450 was created if this option is not specified.
451 "TextFlag => 0|1"
453 This parameter controls the setting of the FLG.FTEXT bit in the
454 gzip header. It is used to signal that the data stored in the gzip
455 file/buffer is probably text.
456 The default is 0.
458 "HeaderCRC => 0|1"
460 When true this parameter will set the FLG.FHCRC bit to 1 in the
461 gzip header and set the CRC16 header field to the CRC of the
462 complete gzip header except the CRC16 field itself.
463 Note that gzip files created with the "HeaderCRC" flag set to 1
465 cannot be read by most, if not all, of the the standard gunzip
466 utilities, most notably gzip version 1.2.4. You should therefore
467 avoid using this option if you want to maximize the portability of
468 your gzip files.
469 This parameter defaults to 0.
471 "OS_Code => $value"
473 Stores $value in the gzip OS header field. A number between 0 and
474 255 is valid.
475 If not specified, this parameter defaults to the OS code of the
477 Operating System this module was built on. The value 3 is used as
478 a catch-all for all Unix variants and unknown Operating Systems.
479 "ExtraField => $data"
481 This parameter allows additional metadata to be stored in the
482 ExtraField in the gzip header. An RFC 1952 compliant ExtraField
483 consists of zero or more subfields. Each subfield consists of a
484 two byte header followed by the subfield data.
485 The list of subfields can be supplied in any of the following
487 formats
488 -ExtraField => [$id1, $data1,
490 $id2, $data2,
491 ...
492 ]
493 -ExtraField => [ [$id1 => $data1],
494 [$id2 => $data2],
495 ...
496 ]
497 -ExtraField => { $id1 => $data1,
498 $id2 => $data2,
499 ...
500 }
501 Where $id1, $id2 are two byte subfield ID's. The second byte of
503 the ID cannot be 0, unless the "Strict" option has been disabled.
504 If you use the hash syntax, you have no control over the order in
506 which the ExtraSubFields are stored, plus you cannot have
507 SubFields with duplicate ID.
508 Alternatively the list of subfields can by supplied as a scalar,
510 thus
511 -ExtraField => $rawdata
513 If you use the raw format, and the "Strict" option is enabled,
515 "IO::Compress::Gzip" will check that $rawdata consists of zero or
516 more conformant sub-fields. When "Strict" is disabled, $rawdata
517 can consist of any arbitrary byte stream.
518 The maximum size of the Extra Field 65535 bytes.
520 "ExtraFlags => $value"
522 Sets the XFL byte in the gzip header to $value.
523 If this option is not present, the value stored in XFL field will
525 be determined by the setting of the "Level" option.
526 If "Level => Z_BEST_SPEED" has been specified then XFL is set to
528 2. If "Level => Z_BEST_COMPRESSION" has been specified then XFL
529 is set to 4. Otherwise XFL is set to 0.
530 "Strict => 0|1"
532 "Strict" will optionally police the values supplied with other
533 options to ensure they are compliant with RFC1952.
534 This option is enabled by default.
536 If "Strict" is enabled the following behaviour will be policed:
538 · The value supplied with the "Name" option can only contain
540 ISO 8859-1 characters.
541 · The value supplied with the "Comment" option can only contain
543 ISO 8859-1 characters plus line-feed.
544 · The values supplied with the "-Name" and "-Comment" options
546 cannot contain multiple embedded nulls.
547 · If an "ExtraField" option is specified and it is a simple
549 scalar, it must conform to the sub-field structure as defined
550 in RFC 1952.
551 · If an "ExtraField" option is specified the second byte of the
553 ID will be checked in each subfield to ensure that it does
554 not contain the reserved value 0x00.
555 When "Strict" is disabled the following behaviour will be policed:
557 · The value supplied with "-Name" option can contain any
559 character except NULL.
560 · The value supplied with "-Comment" option can contain any
562 character except NULL.
563 · The values supplied with the "-Name" and "-Comment" options
565 can contain multiple embedded nulls. The string written to
566 the gzip header will consist of the characters up to, but not
567 including, the first embedded NULL.
568 · If an "ExtraField" option is specified and it is a simple
570 scalar, the structure will not be checked. The only error is
571 if the length is too big.
572 · The ID header in an "ExtraField" sub-field can consist of any
574 two bytes.
575 Examples
577 TODO
578
580 print
581 Usage is
582 $z->print($data)
584 print $z $data
585 Compresses and outputs the contents of the $data parameter. This has
587 the same behaviour as the "print" built-in.
588 Returns true if successful.
590 printf
592 Usage is
593 $z->printf($format, $data)
595 printf $z $format, $data
596 Compresses and outputs the contents of the $data parameter.
598 Returns true if successful.
600 syswrite
602 Usage is
603 $z->syswrite $data
605 $z->syswrite $data, $length
606 $z->syswrite $data, $length, $offset
607 Compresses and outputs the contents of the $data parameter.
609 Returns the number of uncompressed bytes written, or "undef" if
611 unsuccessful.
612 write
614 Usage is
615 $z->write $data
617 $z->write $data, $length
618 $z->write $data, $length, $offset
619 Compresses and outputs the contents of the $data parameter.
621 Returns the number of uncompressed bytes written, or "undef" if
623 unsuccessful.
624 flush
626 Usage is
627 $z->flush;
629 $z->flush($flush_type);
630 Flushes any pending compressed data to the output file/buffer.
632 This method takes an optional parameter, $flush_type, that controls how
634 the flushing will be carried out. By default the $flush_type used is
635 "Z_FINISH". Other valid values for $flush_type are "Z_NO_FLUSH",
636 "Z_SYNC_FLUSH", "Z_FULL_FLUSH" and "Z_BLOCK". It is strongly
637 recommended that you only set the "flush_type" parameter if you fully
638 understand the implications of what it does - overuse of "flush" can
639 seriously degrade the level of compression achieved. See the "zlib"
640 documentation for details.
641 Returns true on success.
643 tell
645 Usage is
646 $z->tell()
648 tell $z
649 Returns the uncompressed file offset.
651 eof
653 Usage is
654 $z->eof();
656 eof($z);
657 Returns true if the "close" method has been called.
659 seek
661 $z->seek($position, $whence);
662 seek($z, $position, $whence);
663 Provides a sub-set of the "seek" functionality, with the restriction
665 that it is only legal to seek forward in the output file/buffer. It is
666 a fatal error to attempt to seek backward.
667 Empty parts of the file/buffer will have NULL (0x00) bytes written to
669 them.
670 The $whence parameter takes one the usual values, namely SEEK_SET,
672 SEEK_CUR or SEEK_END.
673 Returns 1 on success, 0 on failure.
675 binmode
677 Usage is
678 $z->binmode
680 binmode $z ;
681 This is a noop provided for completeness.
683 opened
685 $z->opened()
686 Returns true if the object currently refers to a opened file/buffer.
688 autoflush
690 my $prev = $z->autoflush()
691 my $prev = $z->autoflush(EXPR)
692 If the $z object is associated with a file or a filehandle, this method
694 returns the current autoflush setting for the underlying filehandle. If
695 "EXPR" is present, and is non-zero, it will enable flushing after every
696 write/print operation.
697 If $z is associated with a buffer, this method has no effect and always
699 returns "undef".
700 Note that the special variable $| cannot be used to set or retrieve the
702 autoflush setting.
703 input_line_number
705 $z->input_line_number()
706 $z->input_line_number(EXPR)
707 This method always returns "undef" when compressing.
709 fileno
711 $z->fileno()
712 fileno($z)
713 If the $z object is associated with a file or a filehandle, "fileno"
715 will return the underlying file descriptor. Once the "close" method is
716 called "fileno" will return "undef".
717 If the $z object is associated with a buffer, this method will return
719 "undef".
720 close
722 $z->close() ;
723 close $z ;
724 Flushes any pending compressed data and then closes the output
726 file/buffer.
727 For most versions of Perl this method will be automatically invoked if
729 the IO::Compress::Gzip object is destroyed (either explicitly or by the
730 variable with the reference to the object going out of scope). The
731 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In these
732 cases, the "close" method will be called automatically, but not until
733 global destruction of all live objects when the program is terminating.
734 Therefore, if you want your scripts to be able to run on all versions
736 of Perl, you should call "close" explicitly and not rely on automatic
737 closing.
738 Returns true on success, otherwise 0.
740 If the "AutoClose" option has been enabled when the IO::Compress::Gzip
742 object was created, and the object is associated with a file, the
743 underlying file will also be closed.
744 newStream([OPTS])
746 Usage is
747 $z->newStream( [OPTS] )
749 Closes the current compressed data stream and starts a new one.
751 OPTS consists of any of the the options that are available when
753 creating the $z object.
754 See the "Constructor Options" section for more details.
756 deflateParams
758 Usage is
759 $z->deflateParams
761 TODO
763
765 A number of symbolic constants are required by some methods in
766 "IO::Compress::Gzip". None are imported by default.
767 :all Imports "gzip", $GzipError and all symbolic constants that can be
769 used by "IO::Compress::Gzip". Same as doing this
770 use IO::Compress::Gzip qw(gzip $GzipError :constants) ;
772 :constants
774 Import all symbolic constants. Same as doing this
775 use IO::Compress::Gzip qw(:flush :level :strategy) ;
777 :flush
779 These symbolic constants are used by the "flush" method.
780 Z_NO_FLUSH
782 Z_PARTIAL_FLUSH
783 Z_SYNC_FLUSH
784 Z_FULL_FLUSH
785 Z_FINISH
786 Z_BLOCK
787 :level
789 These symbolic constants are used by the "Level" option in the
790 constructor.
791 Z_NO_COMPRESSION
793 Z_BEST_SPEED
794 Z_BEST_COMPRESSION
795 Z_DEFAULT_COMPRESSION
796 :strategy
798 These symbolic constants are used by the "Strategy" option in the
799 constructor.
800 Z_FILTERED
802 Z_HUFFMAN_ONLY
803 Z_RLE
804 Z_FIXED
805 Z_DEFAULT_STRATEGY
806
808 Apache::GZip Revisited
809 See IO::Compress::FAQ
810 Working with Net::FTP
812 See IO::Compress::FAQ
813
815 Compress::Zlib, IO::Uncompress::Gunzip, IO::Compress::Deflate,
816 IO::Uncompress::Inflate, IO::Compress::RawDeflate,
817 IO::Uncompress::RawInflate, IO::Compress::Bzip2,
818 IO::Uncompress::Bunzip2, IO::Compress::Lzma, IO::Uncompress::UnLzma,
819 IO::Compress::Xz, IO::Uncompress::UnXz, IO::Compress::Lzop,
820 IO::Uncompress::UnLzop, IO::Compress::Lzf, IO::Uncompress::UnLzf,
821 IO::Uncompress::AnyInflate, IO::Uncompress::AnyUncompress
822 IO::Compress::FAQ
824 File::GlobMapper, Archive::Zip, Archive::Tar, IO::Zlib
826 For RFC 1950, 1951 and 1952 see http://www.faqs.org/rfcs/rfc1950.html,
828 http://www.faqs.org/rfcs/rfc1951.html and
829 http://www.faqs.org/rfcs/rfc1952.html
830 The zlib compression library was written by Jean-loup Gailly
832 gzip@prep.ai.mit.edu and Mark Adler madler@alumni.caltech.edu.
833 The primary site for the zlib compression library is
835 http://www.zlib.org.
836 The primary site for gzip is http://www.gzip.org.
838
840 This module was written by Paul Marquess, pmqs@cpan.org.
841
843 See the Changes file.
844
846 Copyright (c) 2005-2013 Paul Marquess. All rights reserved.
847 This program is free software; you can redistribute it and/or modify it
849 under the same terms as Perl itself.
850perl v5.16.3 2013-05-19 IO::Compress::Gzip(3)