2 package IO::Compress::Gzip ;
11 use IO::Compress::RawDeflate;
13 use Compress::Raw::Zlib ;
14 use IO::Compress::Base::Common qw(:Status :Parse createSelfTiedObject);
15 use IO::Compress::Gzip::Constants;
16 use IO::Compress::Zlib::Extra;
20 if (defined &utf8::downgrade )
21 { *noUTF8 = \&utf8::downgrade }
28 our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $GzipError);
30 $VERSION = '2.000_12';
33 @ISA = qw(Exporter IO::Compress::RawDeflate);
34 @EXPORT_OK = qw( $GzipError gzip ) ;
35 %EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;
36 push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
37 Exporter::export_ok_tags('all');
43 my $obj = createSelfTiedObject($class, \$GzipError);
45 $obj->_create(undef, @_);
51 my $obj = createSelfTiedObject(undef, \$GzipError);
52 return $obj->_def(@_);
58 # #return GZIP_MINIMUM_HEADER ;
59 # return $self->mkHeader(*$self->{Got});
68 $self->getZlibParams(),
71 'Minimal' => [0, 1, Parse_boolean, 0],
72 'Comment' => [0, 1, Parse_any, undef],
73 'Name' => [0, 1, Parse_any, undef],
74 'Time' => [0, 1, Parse_any, undef],
75 'TextFlag' => [0, 1, Parse_boolean, 0],
76 'HeaderCRC' => [0, 1, Parse_boolean, 0],
77 'OS_Code' => [0, 1, Parse_unsigned, $Compress::Raw::Zlib::gzip_os_code],
78 'ExtraField'=> [0, 1, Parse_any, undef],
79 'ExtraFlags'=> [0, 1, Parse_any, undef],
90 # gzip always needs crc32
91 $got->value('CRC32' => 1);
94 if $got->value('Merge') ;
96 my $strict = $got->value('Strict') ;
100 if (! $got->parsed('Time') ) {
101 # Modification time defaults to now.
102 $got->value('Time' => time) ;
105 # Check that the Name & Comment don't have embedded NULLs
106 # Also check that they only contain ISO 8859-1 chars.
107 if ($got->parsed('Name') && defined $got->value('Name')) {
108 my $name = $got->value('Name');
110 return $self->saveErrorString(undef, "Null Character found in Name",
112 if $strict && $name =~ /\x00/ ;
114 return $self->saveErrorString(undef, "Non ISO 8859-1 Character found in Name",
116 if $strict && $name =~ /$GZIP_FNAME_INVALID_CHAR_RE/o ;
119 if ($got->parsed('Comment') && defined $got->value('Comment')) {
120 my $comment = $got->value('Comment');
122 return $self->saveErrorString(undef, "Null Character found in Comment",
124 if $strict && $comment =~ /\x00/ ;
126 return $self->saveErrorString(undef, "Non ISO 8859-1 Character found in Comment",
128 if $strict && $comment =~ /$GZIP_FCOMMENT_INVALID_CHAR_RE/o;
131 if ($got->parsed('OS_Code') ) {
132 my $value = $got->value('OS_Code');
134 return $self->saveErrorString(undef, "OS_Code must be between 0 and 255, got '$value'")
135 if $value < 0 || $value > 255 ;
139 # gzip only supports Deflate at present
140 $got->value('Method' => Z_DEFLATED) ;
142 if ( ! $got->parsed('ExtraFlags')) {
143 $got->value('ExtraFlags' => 2)
144 if $got->value('Level') == Z_BEST_SPEED ;
145 $got->value('ExtraFlags' => 4)
146 if $got->value('Level') == Z_BEST_COMPRESSION ;
149 my $data = $got->value('ExtraField') ;
151 my $bad = IO::Compress::Zlib::Extra::parseExtraField($data, $strict, 1) ;
152 return $self->saveErrorString(undef, "Error with ExtraField Parameter: $bad", Z_DATA_ERROR)
155 $got->value('ExtraField', $data) ;
165 return pack("V V", *$self->{Compress}->crc32(),
166 *$self->{UnCompSize_32bit});
171 return ('IO::Uncompress::Gunzip',
172 \$IO::Uncompress::Gunzip::GunzipError);
179 my $filename = shift ;
181 my $defaultTime = (stat($filename))[9] ;
183 $params->value('Name' => $filename)
184 if ! $params->parsed('Name') ;
186 $params->value('Time' => $defaultTime)
187 if ! $params->parsed('Time') ;
196 # stort-circuit if a minimal header is requested.
197 return GZIP_MINIMUM_HEADER if $param->value('Minimal') ;
200 my $method = $param->valueOrDefault('Method', GZIP_CM_DEFLATED) ;
203 my $flags = GZIP_FLG_DEFAULT ;
204 $flags |= GZIP_FLG_FTEXT if $param->value('TextFlag') ;
205 $flags |= GZIP_FLG_FHCRC if $param->value('HeaderCRC') ;
206 $flags |= GZIP_FLG_FEXTRA if $param->wantValue('ExtraField') ;
207 $flags |= GZIP_FLG_FNAME if $param->wantValue('Name') ;
208 $flags |= GZIP_FLG_FCOMMENT if $param->wantValue('Comment') ;
211 my $time = $param->valueOrDefault('Time', GZIP_MTIME_DEFAULT) ;
214 my $extra_flags = $param->valueOrDefault('ExtraFlags', GZIP_XFL_DEFAULT);
217 my $os_code = $param->valueOrDefault('OS_Code', GZIP_OS_DEFAULT) ;
220 my $out = pack("C4 V C C",
223 $method, # Compression Method
225 $time, # Modification Time
226 $extra_flags, # Extra Flags
227 $os_code, # Operating System Code
231 if ($flags & GZIP_FLG_FEXTRA) {
232 my $extra = $param->value('ExtraField') ;
233 $out .= pack("v", length $extra) . $extra ;
237 if ($flags & GZIP_FLG_FNAME) {
238 my $name .= $param->value('Name') ;
239 $name =~ s/\x00.*$//;
241 # Terminate the filename with NULL unless it already is
242 $out .= GZIP_NULL_BYTE
244 substr($name, 1, -1) ne GZIP_NULL_BYTE ;
248 if ($flags & GZIP_FLG_FCOMMENT) {
249 my $comment .= $param->value('Comment') ;
250 $comment =~ s/\x00.*$//;
252 # Terminate the comment with NULL unless it already is
253 $out .= GZIP_NULL_BYTE
254 if ! length $comment or
255 substr($comment, 1, -1) ne GZIP_NULL_BYTE;
259 $out .= pack("v", crc32($out) & 0x00FF ) if $param->value('HeaderCRC') ;
279 IO::Compress::Gzip - Write RFC 1952 files/buffers
285 use IO::Compress::Gzip qw(gzip $GzipError) ;
288 my $status = gzip $input => $output [,OPTS]
289 or die "gzip failed: $GzipError\n";
291 my $z = new IO::Compress::Gzip $output [,OPTS]
292 or die "gzip failed: $GzipError\n";
295 $z->printf($format, $string);
297 $z->syswrite($string [, $length, $offset]);
301 $z->seek($position, $whence);
306 $z->input_line_number();
307 $z->newStream( [OPTS] );
318 printf $z $format, $string;
321 seek $z, $position, $whence
331 B<WARNING -- This is a Beta release>.
335 =item * DO NOT use in production code.
337 =item * The documentation is incomplete in places.
339 =item * Parts of the interface defined here are tentative.
341 =item * Please report any problems you find.
348 This module provides a Perl interface that allows writing compressed
349 data to files or buffer as defined in RFC 1952.
353 All the gzip headers defined in RFC 1952 can be created using
362 For reading RFC 1952 files/buffers, see the companion module
363 L<IO::Uncompress::Gunzip|IO::Uncompress::Gunzip>.
366 =head1 Functional Interface
368 A top-level function, C<gzip>, is provided to carry out
369 "one-shot" compression between buffers and/or files. For finer
370 control over the compression process, see the L</"OO Interface">
373 use IO::Compress::Gzip qw(gzip $GzipError) ;
375 gzip $input => $output [,OPTS]
376 or die "gzip failed: $GzipError\n";
380 The functional interface needs Perl5.005 or better.
383 =head2 gzip $input => $output [, OPTS]
386 C<gzip> expects at least two parameters, C<$input> and C<$output>.
388 =head3 The C<$input> parameter
390 The parameter, C<$input>, is used to define the source of
391 the uncompressed data.
393 It can take one of the following forms:
399 If the C<$input> parameter is a simple scalar, it is assumed to be a
400 filename. This file will be opened for reading and the input data
401 will be read from it.
405 If the C<$input> parameter is a filehandle, the input data will be
407 The string '-' can be used as an alias for standard input.
409 =item A scalar reference
411 If C<$input> is a scalar reference, the input data will be read
414 =item An array reference
416 If C<$input> is an array reference, each element in the array must be a
419 The input data will be read from each file in turn.
421 The complete array will be walked to ensure that it only
422 contains valid filenames before any data is compressed.
426 =item An Input FileGlob string
428 If C<$input> is a string that is delimited by the characters "<" and ">"
429 C<gzip> will assume that it is an I<input fileglob string>. The
430 input is the list of files that match the fileglob.
432 If the fileglob does not match any files ...
434 See L<File::GlobMapper|File::GlobMapper> for more details.
439 If the C<$input> parameter is any other type, C<undef> will be returned.
442 In addition, if C<$input> is a simple filename, the default values for
443 the C<Name> and C<Time> options will be sourced from that file.
445 If you do not want to use these defaults they can be overridden by
446 explicitly setting the C<Name> and C<Time> options or by setting the
447 C<Minimal> parameter.
451 =head3 The C<$output> parameter
453 The parameter C<$output> is used to control the destination of the
454 compressed data. This parameter can take one of these forms.
460 If the C<$output> parameter is a simple scalar, it is assumed to be a
461 filename. This file will be opened for writing and the compressed
462 data will be written to it.
466 If the C<$output> parameter is a filehandle, the compressed data
467 will be written to it.
468 The string '-' can be used as an alias for standard output.
471 =item A scalar reference
473 If C<$output> is a scalar reference, the compressed data will be
474 stored in C<$$output>.
478 =item An Array Reference
480 If C<$output> is an array reference, the compressed data will be
481 pushed onto the array.
483 =item An Output FileGlob
485 If C<$output> is a string that is delimited by the characters "<" and ">"
486 C<gzip> will assume that it is an I<output fileglob string>. The
487 output is the list of files that match the fileglob.
489 When C<$output> is an fileglob string, C<$input> must also be a fileglob
490 string. Anything else is an error.
494 If the C<$output> parameter is any other type, C<undef> will be returned.
502 When C<$input> maps to multiple files/buffers and C<$output> is a single
503 file/buffer the input files/buffers will be stored
504 in C<$output> as a concatenated series of compressed data streams.
511 =head2 Optional Parameters
513 Unless specified below, the optional parameters for C<gzip>,
514 C<OPTS>, are the same as those used with the OO interface defined in the
515 L</"Constructor Options"> section below.
519 =item AutoClose =E<gt> 0|1
521 This option applies to any input or output data streams to
522 C<gzip> that are filehandles.
524 If C<AutoClose> is specified, and the value is true, it will result in all
525 input and/or output filehandles being closed once C<gzip> has
528 This parameter defaults to 0.
532 =item BinModeIn =E<gt> 0|1
534 When reading from a file or filehandle, set C<binmode> before reading.
542 =item -Append =E<gt> 0|1
553 To read the contents of the file C<file1.txt> and write the compressed
554 data to the file C<file1.txt.gz>.
558 use IO::Compress::Gzip qw(gzip $GzipError) ;
560 my $input = "file1.txt";
561 gzip $input => "$input.gz"
562 or die "gzip failed: $GzipError\n";
565 To read from an existing Perl filehandle, C<$input>, and write the
566 compressed data to a buffer, C<$buffer>.
570 use IO::Compress::Gzip qw(gzip $GzipError) ;
573 my $input = new IO::File "<file1.txt"
574 or die "Cannot open 'file1.txt': $!\n" ;
576 gzip $input => \$buffer
577 or die "gzip failed: $GzipError\n";
579 To compress all files in the directory "/my/home" that match "*.txt"
580 and store the compressed data in the same directory
584 use IO::Compress::Gzip qw(gzip $GzipError) ;
586 gzip '</my/home/*.txt>' => '<*.gz>'
587 or die "gzip failed: $GzipError\n";
589 and if you want to compress each file one at a time, this will do the trick
593 use IO::Compress::Gzip qw(gzip $GzipError) ;
595 for my $input ( glob "/my/home/*.txt" )
597 my $output = "$input.gz" ;
598 gzip $input => $output
599 or die "Error compressing '$input': $GzipError\n";
607 The format of the constructor for C<IO::Compress::Gzip> is shown below
609 my $z = new IO::Compress::Gzip $output [,OPTS]
610 or die "IO::Compress::Gzip failed: $GzipError\n";
612 It returns an C<IO::Compress::Gzip> object on success and undef on failure.
613 The variable C<$GzipError> will contain an error message on failure.
615 If you are running Perl 5.005 or better the object, C<$z>, returned from
616 IO::Compress::Gzip can be used exactly like an L<IO::File|IO::File> filehandle.
617 This means that all normal output file operations can be carried out
619 For example, to write to a compressed file/buffer you can use either of
622 $z->print("hello world\n");
623 print $z "hello world\n";
625 The mandatory parameter C<$output> is used to control the destination
626 of the compressed data. This parameter can take one of these forms.
632 If the C<$output> parameter is a simple scalar, it is assumed to be a
633 filename. This file will be opened for writing and the compressed data
634 will be written to it.
638 If the C<$output> parameter is a filehandle, the compressed data will be
640 The string '-' can be used as an alias for standard output.
643 =item A scalar reference
645 If C<$output> is a scalar reference, the compressed data will be stored
650 If the C<$output> parameter is any other type, C<IO::Compress::Gzip>::new will
653 =head2 Constructor Options
655 C<OPTS> is any combination of the following options:
659 =item AutoClose =E<gt> 0|1
661 This option is only valid when the C<$output> parameter is a filehandle. If
662 specified, and the value is true, it will result in the C<$output> being
663 closed once either the C<close> method is called or the C<IO::Compress::Gzip>
666 This parameter defaults to 0.
668 =item Append =E<gt> 0|1
670 Opens C<$output> in append mode.
672 The behaviour of this option is dependent on the type of C<$output>.
678 If C<$output> is a buffer and C<Append> is enabled, all compressed data
679 will be append to the end if C<$output>. Otherwise C<$output> will be
680 cleared before any data is written to it.
684 If C<$output> is a filename and C<Append> is enabled, the file will be
685 opened in append mode. Otherwise the contents of the file, if any, will be
686 truncated before any compressed data is written to it.
690 If C<$output> is a filehandle, the file pointer will be positioned to the
691 end of the file via a call to C<seek> before any compressed data is written
692 to it. Otherwise the file pointer will not be moved.
696 This parameter defaults to 0.
702 =item Merge =E<gt> 0|1
704 This option is used to compress input data and append it to an existing
705 compressed data stream in C<$output>. The end result is a single compressed
706 data stream stored in C<$output>.
710 It is a fatal error to attempt to use this option when C<$output> is not an
711 RFC 1952 data stream.
715 There are a number of other limitations with the C<Merge> option:
721 This module needs to have been built with zlib 1.2.1 or better to work. A
722 fatal error will be thrown if C<Merge> is used with an older version of
727 If C<$output> is a file or a filehandle, it must be seekable.
732 This parameter defaults to 0.
738 Defines the compression level used by zlib. The value should either be
739 a number between 0 and 9 (0 means no compression and 9 is maximum
740 compression), or one of the symbolic constants defined below.
745 Z_DEFAULT_COMPRESSION
747 The default is Z_DEFAULT_COMPRESSION.
749 Note, these constants are not imported by C<IO::Compress::Gzip> by default.
751 use IO::Compress::Gzip qw(:strategy);
752 use IO::Compress::Gzip qw(:constants);
753 use IO::Compress::Gzip qw(:all);
757 Defines the strategy used to tune the compression. Use one of the symbolic
758 constants defined below.
766 The default is Z_DEFAULT_STRATEGY.
773 =item -Minimal =E<gt> 0|1
775 If specified, this option will force the creation of the smallest possible
776 compliant gzip header (which is exactly 10 bytes long) as defined in
779 See the section titled "Compliance" in RFC 1952 for a definition
780 of the values used for the fields in the gzip header.
782 All other parameters that control the content of the gzip header will
783 be ignored if this parameter is set to 1.
785 This parameter defaults to 0.
787 =item -Comment =E<gt> $comment
789 Stores the contents of C<$comment> in the COMMENT field in
791 By default, no comment field is written to the gzip file.
793 If the C<-Strict> option is enabled, the comment can only consist of ISO
794 8859-1 characters plus line feed.
796 If the C<-Strict> option is disabled, the comment field can contain any
797 character except NULL. If any null characters are present, the field
798 will be truncated at the first NULL.
800 =item -Name =E<gt> $string
802 Stores the contents of C<$string> in the gzip NAME header field. If
803 C<Name> is not specified, no gzip NAME field will be created.
805 If the C<-Strict> option is enabled, C<$string> can only consist of ISO
808 If C<-Strict> is disabled, then C<$string> can contain any character
809 except NULL. If any null characters are present, the field will be
810 truncated at the first NULL.
812 =item -Time =E<gt> $number
814 Sets the MTIME field in the gzip header to $number.
816 This field defaults to the time the C<IO::Compress::Gzip> object was created
817 if this option is not specified.
819 =item -TextFlag =E<gt> 0|1
821 This parameter controls the setting of the FLG.FTEXT bit in the gzip
822 header. It is used to signal that the data stored in the gzip file/buffer
827 =item -HeaderCRC =E<gt> 0|1
829 When true this parameter will set the FLG.FHCRC bit to 1 in the gzip header
830 and set the CRC16 header field to the CRC of the complete gzip header
831 except the CRC16 field itself.
833 B<Note> that gzip files created with the C<HeaderCRC> flag set to 1 cannot
834 be read by most, if not all, of the the standard gunzip utilities, most
835 notably gzip version 1.2.4. You should therefore avoid using this option if
836 you want to maximize the portability of your gzip files.
838 This parameter defaults to 0.
840 =item -OS_Code =E<gt> $value
842 Stores C<$value> in the gzip OS header field. A number between 0 and 255 is
845 If not specified, this parameter defaults to the OS code of the Operating
846 System this module was built on. The value 3 is used as a catch-all for all
847 Unix variants and unknown Operating Systems.
849 =item -ExtraField =E<gt> $data
851 This parameter allows additional metadata to be stored in the ExtraField in
852 the gzip header. An RFC 1952 compliant ExtraField consists of zero or more
853 subfields. Each subfield consists of a two byte header followed by the
856 The list of subfields can be supplied in any of the following formats
858 -ExtraField => [$id1, $data1,
862 -ExtraField => [ [$id1 => $data1],
866 -ExtraField => { $id1 => $data1,
871 Where C<$id1>, C<$id2> are two byte subfield ID's. The second byte of
872 the ID cannot be 0, unless the C<Strict> option has been disabled.
874 If you use the hash syntax, you have no control over the order in which
875 the ExtraSubFields are stored, plus you cannot have SubFields with
878 Alternatively the list of subfields can by supplied as a scalar, thus
880 -ExtraField => $rawdata
882 If you use the raw format, and the C<Strict> option is enabled,
883 C<IO::Compress::Gzip> will check that C<$rawdata> consists of zero or more
884 conformant sub-fields. When C<Strict> is disabled, C<$rawdata> can
885 consist of any arbitrary byte stream.
887 The maximum size of the Extra Field 65535 bytes.
889 =item -ExtraFlags =E<gt> $value
891 Sets the XFL byte in the gzip header to C<$value>.
893 If this option is not present, the value stored in XFL field will be
894 determined by the setting of the C<Level> option.
896 If C<Level =E<gt> Z_BEST_SPEED> has been specified then XFL is set to 2.
897 If C<Level =E<gt> Z_BEST_COMPRESSION> has been specified then XFL is set to 4.
898 Otherwise XFL is set to 0.
902 =item -Strict =E<gt> 0|1
906 C<Strict> will optionally police the values supplied with other options
907 to ensure they are compliant with RFC1952.
909 This option is enabled by default.
911 If C<Strict> is enabled the following behaviour will be policed:
917 The value supplied with the C<Name> option can only contain ISO 8859-1
922 The value supplied with the C<Comment> option can only contain ISO 8859-1
923 characters plus line-feed.
927 The values supplied with the C<-Name> and C<-Comment> options cannot
928 contain multiple embedded nulls.
932 If an C<ExtraField> option is specified and it is a simple scalar,
933 it must conform to the sub-field structure as defined in RFC 1952.
937 If an C<ExtraField> option is specified the second byte of the ID will be
938 checked in each subfield to ensure that it does not contain the reserved
943 When C<Strict> is disabled the following behaviour will be policed:
949 The value supplied with C<-Name> option can contain
950 any character except NULL.
954 The value supplied with C<-Comment> option can contain any character
959 The values supplied with the C<-Name> and C<-Comment> options can contain
960 multiple embedded nulls. The string written to the gzip header will
961 consist of the characters up to, but not including, the first embedded
966 If an C<ExtraField> option is specified and it is a simple scalar, the
967 structure will not be checked. The only error is if the length is too big.
971 The ID header in an C<ExtraField> sub-field can consist of any two bytes.
992 Compresses and outputs the contents of the C<$data> parameter. This
993 has the same behaviour as the C<print> built-in.
995 Returns true if successful.
1001 $z->printf($format, $data)
1002 printf $z $format, $data
1004 Compresses and outputs the contents of the C<$data> parameter.
1006 Returns true if successful.
1013 $z->syswrite $data, $length
1014 $z->syswrite $data, $length, $offset
1016 Compresses and outputs the contents of the C<$data> parameter.
1018 Returns the number of uncompressed bytes written, or C<undef> if
1026 $z->write $data, $length
1027 $z->write $data, $length, $offset
1029 Compresses and outputs the contents of the C<$data> parameter.
1031 Returns the number of uncompressed bytes written, or C<undef> if
1040 $z->flush($flush_type);
1043 Flushes any pending compressed data to the output file/buffer.
1046 This method takes an optional parameter, C<$flush_type>, that controls
1047 how the flushing will be carried out. By default the C<$flush_type>
1048 used is C<Z_FINISH>. Other valid values for C<$flush_type> are
1049 C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
1050 strongly recommended that you only set the C<flush_type> parameter if
1051 you fully understand the implications of what it does - overuse of C<flush>
1052 can seriously degrade the level of compression achieved. See the C<zlib>
1053 documentation for details.
1056 Returns true on success.
1066 Returns the uncompressed file offset.
1077 Returns true if the C<close> method has been called.
1083 $z->seek($position, $whence);
1084 seek($z, $position, $whence);
1089 Provides a sub-set of the C<seek> functionality, with the restriction
1090 that it is only legal to seek forward in the output file/buffer.
1091 It is a fatal error to attempt to seek backward.
1093 Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
1097 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
1098 SEEK_CUR or SEEK_END.
1100 Returns 1 on success, 0 on failure.
1109 This is a noop provided for completeness.
1115 Returns true if the object currently refers to a opened file/buffer.
1119 my $prev = $z->autoflush()
1120 my $prev = $z->autoflush(EXPR)
1122 If the C<$z> object is associated with a file or a filehandle, this method
1123 returns the current autoflush setting for the underlying filehandle. If
1124 C<EXPR> is present, and is non-zero, it will enable flushing after every
1125 write/print operation.
1127 If C<$z> is associated with a buffer, this method has no effect and always
1130 B<Note> that the special variable C<$|> B<cannot> be used to set or
1131 retrieve the autoflush setting.
1133 =head2 input_line_number
1135 $z->input_line_number()
1136 $z->input_line_number(EXPR)
1139 This method always returns C<undef> when compressing.
1148 If the C<$z> object is associated with a file or a filehandle, this method
1149 will return the underlying file descriptor.
1151 If the C<$z> object is is associated with a buffer, this method will
1161 Flushes any pending compressed data and then closes the output file/buffer.
1165 For most versions of Perl this method will be automatically invoked if
1166 the IO::Compress::Gzip object is destroyed (either explicitly or by the
1167 variable with the reference to the object going out of scope). The
1168 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1169 these cases, the C<close> method will be called automatically, but
1170 not until global destruction of all live objects when the program is
1173 Therefore, if you want your scripts to be able to run on all versions
1174 of Perl, you should call C<close> explicitly and not rely on automatic
1177 Returns true on success, otherwise 0.
1179 If the C<AutoClose> option has been enabled when the IO::Compress::Gzip
1180 object was created, and the object is associated with a file, the
1181 underlying file will also be closed.
1186 =head2 newStream([OPTS])
1190 $z->newStream( [OPTS] )
1192 Closes the current compressed data stream and starts a new one.
1194 OPTS consists of the following sub-set of the the options that are
1195 available when creating the C<$z> object,
1208 =head2 deflateParams
1220 A number of symbolic constants are required by some methods in
1221 C<IO::Compress::Gzip>. None are imported by default.
1230 Imports C<gzip>, C<$GzipError> and all symbolic
1231 constants that can be used by C<IO::Compress::Gzip>. Same as doing this
1233 use IO::Compress::Gzip qw(gzip $GzipError :constants) ;
1237 Import all symbolic constants. Same as doing this
1240 use IO::Compress::Gzip qw(:flush :level :strategy) ;
1245 These symbolic constants are used by the C<flush> method.
1256 These symbolic constants are used by the C<Level> option in the constructor.
1261 Z_DEFAULT_COMPRESSION
1266 These symbolic constants are used by the C<Strategy> option in the constructor.
1292 L<Compress::Zlib>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, 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::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
1294 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1296 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1297 L<Archive::Tar|Archive::Tar>,
1298 L<IO::Zlib|IO::Zlib>
1301 For RFC 1950, 1951 and 1952 see
1302 F<http://www.faqs.org/rfcs/rfc1950.html>,
1303 F<http://www.faqs.org/rfcs/rfc1951.html> and
1304 F<http://www.faqs.org/rfcs/rfc1952.html>
1306 The I<zlib> compression library was written by Jean-loup Gailly
1307 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1309 The primary site for the I<zlib> compression library is
1310 F<http://www.zlib.org>.
1312 The primary site for gzip is F<http://www.gzip.org>.
1319 This module was written by Paul Marquess, F<pmqs@cpan.org>.
1323 =head1 MODIFICATION HISTORY
1325 See the Changes file.
1327 =head1 COPYRIGHT AND LICENSE
1329 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
1331 This program is free software; you can redistribute it and/or
1332 modify it under the same terms as Perl itself.