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_13';
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}->get32bit());
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 C<< AutoClose => 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.
531 =item C<< BinModeIn => 0|1 >>
533 When reading from a file or filehandle, set C<binmode> before reading.
541 =item C<< Append => 0|1 >>
552 To read the contents of the file C<file1.txt> and write the compressed
553 data to the file C<file1.txt.gz>.
557 use IO::Compress::Gzip qw(gzip $GzipError) ;
559 my $input = "file1.txt";
560 gzip $input => "$input.gz"
561 or die "gzip failed: $GzipError\n";
564 To read from an existing Perl filehandle, C<$input>, and write the
565 compressed data to a buffer, C<$buffer>.
569 use IO::Compress::Gzip qw(gzip $GzipError) ;
572 my $input = new IO::File "<file1.txt"
573 or die "Cannot open 'file1.txt': $!\n" ;
575 gzip $input => \$buffer
576 or die "gzip failed: $GzipError\n";
578 To compress all files in the directory "/my/home" that match "*.txt"
579 and store the compressed data in the same directory
583 use IO::Compress::Gzip qw(gzip $GzipError) ;
585 gzip '</my/home/*.txt>' => '<*.gz>'
586 or die "gzip failed: $GzipError\n";
588 and if you want to compress each file one at a time, this will do the trick
592 use IO::Compress::Gzip qw(gzip $GzipError) ;
594 for my $input ( glob "/my/home/*.txt" )
596 my $output = "$input.gz" ;
597 gzip $input => $output
598 or die "Error compressing '$input': $GzipError\n";
606 The format of the constructor for C<IO::Compress::Gzip> is shown below
608 my $z = new IO::Compress::Gzip $output [,OPTS]
609 or die "IO::Compress::Gzip failed: $GzipError\n";
611 It returns an C<IO::Compress::Gzip> object on success and undef on failure.
612 The variable C<$GzipError> will contain an error message on failure.
614 If you are running Perl 5.005 or better the object, C<$z>, returned from
615 IO::Compress::Gzip can be used exactly like an L<IO::File|IO::File> filehandle.
616 This means that all normal output file operations can be carried out
618 For example, to write to a compressed file/buffer you can use either of
621 $z->print("hello world\n");
622 print $z "hello world\n";
624 The mandatory parameter C<$output> is used to control the destination
625 of the compressed data. This parameter can take one of these forms.
631 If the C<$output> parameter is a simple scalar, it is assumed to be a
632 filename. This file will be opened for writing and the compressed data
633 will be written to it.
637 If the C<$output> parameter is a filehandle, the compressed data will be
639 The string '-' can be used as an alias for standard output.
642 =item A scalar reference
644 If C<$output> is a scalar reference, the compressed data will be stored
649 If the C<$output> parameter is any other type, C<IO::Compress::Gzip>::new will
652 =head2 Constructor Options
654 C<OPTS> is any combination of the following options:
658 =item C<< AutoClose => 0|1 >>
660 This option is only valid when the C<$output> parameter is a filehandle. If
661 specified, and the value is true, it will result in the C<$output> being
662 closed once either the C<close> method is called or the C<IO::Compress::Gzip>
665 This parameter defaults to 0.
667 =item C<< Append => 0|1 >>
669 Opens C<$output> in append mode.
671 The behaviour of this option is dependent on the type of C<$output>.
677 If C<$output> is a buffer and C<Append> is enabled, all compressed data
678 will be append to the end if C<$output>. Otherwise C<$output> will be
679 cleared before any data is written to it.
683 If C<$output> is a filename and C<Append> is enabled, the file will be
684 opened in append mode. Otherwise the contents of the file, if any, will be
685 truncated before any compressed data is written to it.
689 If C<$output> is a filehandle, the file pointer will be positioned to the
690 end of the file via a call to C<seek> before any compressed data is written
691 to it. Otherwise the file pointer will not be moved.
695 This parameter defaults to 0.
701 =item C<< Merge => 0|1 >>
703 This option is used to compress input data and append it to an existing
704 compressed data stream in C<$output>. The end result is a single compressed
705 data stream stored in C<$output>.
709 It is a fatal error to attempt to use this option when C<$output> is not an
710 RFC 1952 data stream.
714 There are a number of other limitations with the C<Merge> option:
720 This module needs to have been built with zlib 1.2.1 or better to work. A
721 fatal error will be thrown if C<Merge> is used with an older version of
726 If C<$output> is a file or a filehandle, it must be seekable.
731 This parameter defaults to 0.
737 Defines the compression level used by zlib. The value should either be
738 a number between 0 and 9 (0 means no compression and 9 is maximum
739 compression), or one of the symbolic constants defined below.
744 Z_DEFAULT_COMPRESSION
746 The default is Z_DEFAULT_COMPRESSION.
748 Note, these constants are not imported by C<IO::Compress::Gzip> by default.
750 use IO::Compress::Gzip qw(:strategy);
751 use IO::Compress::Gzip qw(:constants);
752 use IO::Compress::Gzip qw(:all);
756 Defines the strategy used to tune the compression. Use one of the symbolic
757 constants defined below.
765 The default is Z_DEFAULT_STRATEGY.
772 =item C<< Minimal => 0|1 >>
774 If specified, this option will force the creation of the smallest possible
775 compliant gzip header (which is exactly 10 bytes long) as defined in
778 See the section titled "Compliance" in RFC 1952 for a definition
779 of the values used for the fields in the gzip header.
781 All other parameters that control the content of the gzip header will
782 be ignored if this parameter is set to 1.
784 This parameter defaults to 0.
786 =item C<< Comment => $comment >>
788 Stores the contents of C<$comment> in the COMMENT field in
790 By default, no comment field is written to the gzip file.
792 If the C<-Strict> option is enabled, the comment can only consist of ISO
793 8859-1 characters plus line feed.
795 If the C<-Strict> option is disabled, the comment field can contain any
796 character except NULL. If any null characters are present, the field
797 will be truncated at the first NULL.
799 =item C<< Name => $string >>
801 Stores the contents of C<$string> in the gzip NAME header field. If
802 C<Name> is not specified, no gzip NAME field will be created.
804 If the C<-Strict> option is enabled, C<$string> can only consist of ISO
807 If C<-Strict> is disabled, then C<$string> can contain any character
808 except NULL. If any null characters are present, the field will be
809 truncated at the first NULL.
811 =item C<< Time => $number >>
813 Sets the MTIME field in the gzip header to $number.
815 This field defaults to the time the C<IO::Compress::Gzip> object was created
816 if this option is not specified.
818 =item C<< TextFlag => 0|1 >>
820 This parameter controls the setting of the FLG.FTEXT bit in the gzip
821 header. It is used to signal that the data stored in the gzip file/buffer
826 =item C<< HeaderCRC => 0|1 >>
828 When true this parameter will set the FLG.FHCRC bit to 1 in the gzip header
829 and set the CRC16 header field to the CRC of the complete gzip header
830 except the CRC16 field itself.
832 B<Note> that gzip files created with the C<HeaderCRC> flag set to 1 cannot
833 be read by most, if not all, of the the standard gunzip utilities, most
834 notably gzip version 1.2.4. You should therefore avoid using this option if
835 you want to maximize the portability of your gzip files.
837 This parameter defaults to 0.
839 =item C<< OS_Code => $value >>
841 Stores C<$value> in the gzip OS header field. A number between 0 and 255 is
844 If not specified, this parameter defaults to the OS code of the Operating
845 System this module was built on. The value 3 is used as a catch-all for all
846 Unix variants and unknown Operating Systems.
848 =item C<< ExtraField => $data >>
850 This parameter allows additional metadata to be stored in the ExtraField in
851 the gzip header. An RFC 1952 compliant ExtraField consists of zero or more
852 subfields. Each subfield consists of a two byte header followed by the
855 The list of subfields can be supplied in any of the following formats
857 -ExtraField => [$id1, $data1,
861 -ExtraField => [ [$id1 => $data1],
865 -ExtraField => { $id1 => $data1,
870 Where C<$id1>, C<$id2> are two byte subfield ID's. The second byte of
871 the ID cannot be 0, unless the C<Strict> option has been disabled.
873 If you use the hash syntax, you have no control over the order in which
874 the ExtraSubFields are stored, plus you cannot have SubFields with
877 Alternatively the list of subfields can by supplied as a scalar, thus
879 -ExtraField => $rawdata
881 If you use the raw format, and the C<Strict> option is enabled,
882 C<IO::Compress::Gzip> will check that C<$rawdata> consists of zero or more
883 conformant sub-fields. When C<Strict> is disabled, C<$rawdata> can
884 consist of any arbitrary byte stream.
886 The maximum size of the Extra Field 65535 bytes.
888 =item C<< ExtraFlags => $value >>
890 Sets the XFL byte in the gzip header to C<$value>.
892 If this option is not present, the value stored in XFL field will be
893 determined by the setting of the C<Level> option.
895 If C<< Level => Z_BEST_SPEED >> has been specified then XFL is set to 2.
896 If C<< Level => Z_BEST_COMPRESSION >> has been specified then XFL is set to 4.
897 Otherwise XFL is set to 0.
901 =item C<< Strict => 0|1 >>
905 C<Strict> will optionally police the values supplied with other options
906 to ensure they are compliant with RFC1952.
908 This option is enabled by default.
910 If C<Strict> is enabled the following behaviour will be policed:
916 The value supplied with the C<Name> option can only contain ISO 8859-1
921 The value supplied with the C<Comment> option can only contain ISO 8859-1
922 characters plus line-feed.
926 The values supplied with the C<-Name> and C<-Comment> options cannot
927 contain multiple embedded nulls.
931 If an C<ExtraField> option is specified and it is a simple scalar,
932 it must conform to the sub-field structure as defined in RFC 1952.
936 If an C<ExtraField> option is specified the second byte of the ID will be
937 checked in each subfield to ensure that it does not contain the reserved
942 When C<Strict> is disabled the following behaviour will be policed:
948 The value supplied with C<-Name> option can contain
949 any character except NULL.
953 The value supplied with C<-Comment> option can contain any character
958 The values supplied with the C<-Name> and C<-Comment> options can contain
959 multiple embedded nulls. The string written to the gzip header will
960 consist of the characters up to, but not including, the first embedded
965 If an C<ExtraField> option is specified and it is a simple scalar, the
966 structure will not be checked. The only error is if the length is too big.
970 The ID header in an C<ExtraField> sub-field can consist of any two bytes.
991 Compresses and outputs the contents of the C<$data> parameter. This
992 has the same behaviour as the C<print> built-in.
994 Returns true if successful.
1000 $z->printf($format, $data)
1001 printf $z $format, $data
1003 Compresses and outputs the contents of the C<$data> parameter.
1005 Returns true if successful.
1012 $z->syswrite $data, $length
1013 $z->syswrite $data, $length, $offset
1015 Compresses and outputs the contents of the C<$data> parameter.
1017 Returns the number of uncompressed bytes written, or C<undef> if
1025 $z->write $data, $length
1026 $z->write $data, $length, $offset
1028 Compresses and outputs the contents of the C<$data> parameter.
1030 Returns the number of uncompressed bytes written, or C<undef> if
1039 $z->flush($flush_type);
1042 Flushes any pending compressed data to the output file/buffer.
1045 This method takes an optional parameter, C<$flush_type>, that controls
1046 how the flushing will be carried out. By default the C<$flush_type>
1047 used is C<Z_FINISH>. Other valid values for C<$flush_type> are
1048 C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
1049 strongly recommended that you only set the C<flush_type> parameter if
1050 you fully understand the implications of what it does - overuse of C<flush>
1051 can seriously degrade the level of compression achieved. See the C<zlib>
1052 documentation for details.
1055 Returns true on success.
1065 Returns the uncompressed file offset.
1076 Returns true if the C<close> method has been called.
1082 $z->seek($position, $whence);
1083 seek($z, $position, $whence);
1088 Provides a sub-set of the C<seek> functionality, with the restriction
1089 that it is only legal to seek forward in the output file/buffer.
1090 It is a fatal error to attempt to seek backward.
1092 Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
1096 The C<$whence> parameter takes one the usual values, namely SEEK_SET,
1097 SEEK_CUR or SEEK_END.
1099 Returns 1 on success, 0 on failure.
1108 This is a noop provided for completeness.
1114 Returns true if the object currently refers to a opened file/buffer.
1118 my $prev = $z->autoflush()
1119 my $prev = $z->autoflush(EXPR)
1121 If the C<$z> object is associated with a file or a filehandle, this method
1122 returns the current autoflush setting for the underlying filehandle. If
1123 C<EXPR> is present, and is non-zero, it will enable flushing after every
1124 write/print operation.
1126 If C<$z> is associated with a buffer, this method has no effect and always
1129 B<Note> that the special variable C<$|> B<cannot> be used to set or
1130 retrieve the autoflush setting.
1132 =head2 input_line_number
1134 $z->input_line_number()
1135 $z->input_line_number(EXPR)
1138 This method always returns C<undef> when compressing.
1147 If the C<$z> object is associated with a file or a filehandle, this method
1148 will return the underlying file descriptor.
1150 If the C<$z> object is is associated with a buffer, this method will
1160 Flushes any pending compressed data and then closes the output file/buffer.
1164 For most versions of Perl this method will be automatically invoked if
1165 the IO::Compress::Gzip object is destroyed (either explicitly or by the
1166 variable with the reference to the object going out of scope). The
1167 exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
1168 these cases, the C<close> method will be called automatically, but
1169 not until global destruction of all live objects when the program is
1172 Therefore, if you want your scripts to be able to run on all versions
1173 of Perl, you should call C<close> explicitly and not rely on automatic
1176 Returns true on success, otherwise 0.
1178 If the C<AutoClose> option has been enabled when the IO::Compress::Gzip
1179 object was created, and the object is associated with a file, the
1180 underlying file will also be closed.
1185 =head2 newStream([OPTS])
1189 $z->newStream( [OPTS] )
1191 Closes the current compressed data stream and starts a new one.
1193 OPTS consists of any of the the options that are available when creating
1196 See the L</"Constructor Options"> section for more details.
1199 =head2 deflateParams
1211 A number of symbolic constants are required by some methods in
1212 C<IO::Compress::Gzip>. None are imported by default.
1221 Imports C<gzip>, C<$GzipError> and all symbolic
1222 constants that can be used by C<IO::Compress::Gzip>. Same as doing this
1224 use IO::Compress::Gzip qw(gzip $GzipError :constants) ;
1228 Import all symbolic constants. Same as doing this
1231 use IO::Compress::Gzip qw(:flush :level :strategy) ;
1236 These symbolic constants are used by the C<flush> method.
1247 These symbolic constants are used by the C<Level> option in the constructor.
1252 Z_DEFAULT_COMPRESSION
1257 These symbolic constants are used by the C<Strategy> option in the constructor.
1288 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>
1290 L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
1292 L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
1293 L<Archive::Tar|Archive::Tar>,
1294 L<IO::Zlib|IO::Zlib>
1297 For RFC 1950, 1951 and 1952 see
1298 F<http://www.faqs.org/rfcs/rfc1950.html>,
1299 F<http://www.faqs.org/rfcs/rfc1951.html> and
1300 F<http://www.faqs.org/rfcs/rfc1952.html>
1302 The I<zlib> compression library was written by Jean-loup Gailly
1303 F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
1305 The primary site for the I<zlib> compression library is
1306 F<http://www.zlib.org>.
1308 The primary site for gzip is F<http://www.gzip.org>.
1315 This module was written by Paul Marquess, F<pmqs@cpan.org>.
1319 =head1 MODIFICATION HISTORY
1321 See the Changes file.
1323 =head1 COPYRIGHT AND LICENSE
1325 Copyright (c) 2005-2006 Paul Marquess. All rights reserved.
1327 This program is free software; you can redistribute it and/or
1328 modify it under the same terms as Perl itself.