1Compress::Bzip2(3) User Contributed Perl Documentation Compress::Bzip2(3)
2
6 Compress::Bzip2 - Interface to Bzip2 compression library
7
9 use Compress::Bzip2 qw(:all :constant :utilities :gzip);
10 ($bz, $status) = bzdeflateInit( [PARAMS] );
12 ($out, $status) = $bz->bzdeflate($buffer) ; # compress
13 ($bz, $status) = bzinflateInit( [PARAMS] );
15 ($out, $status) = $bz->bzinflate($buffer); # uncompress
16 ($out, $status) = $bz->bzflush() ;
18 ($out, $status) = $bz->bzclose() ;
19 $dest = memBzip($source);
21 alias compress
22 $dest = memBunzip($source);
23 alias decompress
24 $bz = Compress::Bzip2->new( [PARAMS] );
26 $bz = bzopen($filename or filehandle, $mode);
28 alternate, with $bz created by new():
29 $bz->bzopen($filename or filehandle, $mode);
30 $bytesread = $bz->bzread($buffer [,$size]) ;
32 $bytesread = $bz->bzreadline($line);
33 $byteswritten = $bz->bzwrite($buffer [,$limit]);
34 $errstring = $bz->bzerror();
35 $status = $bz->bzeof();
36 $status = $bz->bzflush();
37 $status = $bz->bzclose() ;
38 $status = $bz->bzsetparams( $param => $setting );
40 $bz->total_in() ;
42 $bz->total_out() ;
43 $verstring = $bz->bzversion();
45 $Compress::Bzip2::bzerrno
47
49 The Compress::Bzip2 module provides a Perl interface to the bzip2
50 compression library (see "AUTHOR" for details about where to get
51 Bzip2). A relevant subset of the functionality provided by bzip2 is
52 available in Compress::Bzip2.
53 All string parameters can either be a scalar or a scalar reference.
55 The module can be split into two general areas of functionality, namely
57 in-memory compression/decompression and read/write access to bzip2
58 files. Each of these areas will be discussed separately below.
59 NOTE
61 Compress::Bzip2 is just a simple bzip2 binding, comparable to the old
63 Compress::Zlib library. It is not well integrated into PerlIO, use the
64 preferred IO::Compress::Bzip2 instead.
65
67 A number of functions are supplied in bzlib for reading and writing
68 bzip2 files. Unfortunately, most of them are not suitable. So, this
69 module provides another interface, built over top of the low level
70 bzlib methods.
71 $bz = bzopen(filename or filehandle, mode)
73 This function returns an object which is used to access the other bzip2
74 methods.
75 The mode parameter is used to specify both whether the file is opened
77 for reading or writing, with "r" or "w" respectively.
78 If a reference to an open filehandle is passed in place of the
80 filename, it better be positioned to the start of a
81 compression/decompression sequence.
82 WARNING: With Perl 5.6 you cannot use a filehandle because of SEGV in
84 destruction with bzclose or an implicit close.
85 $bz = Compress::Bzip2->new( [PARAMS] )
87 Create a Compress::Bzip2 object. Optionally, provide
88 compression/decompression parameters as a keyword => setting list. See
89 bzsetparams() for a description of the parameters.
90 $bz->bzopen(filename or filehandle, mode)
92 This is bzopen, but it uses an object previously created by the new
93 method. Other than that, it is identical to the above bzopen.
94 $bytesread = $bz->bzread($buffer [, $size]) ;
96 Reads $size bytes from the compressed file into $buffer. If $size is
97 not specified, it will default to 4096. If the scalar $buffer is not
98 large enough, it will be extended automatically.
99 Returns the number of bytes actually read. On EOF it returns 0 and in
101 the case of an error, -1.
102 $bytesread = $bz->bzreadline($line) ;
104 Reads the next line from the compressed file into $line.
105 Returns the number of bytes actually read. On EOF it returns 0 and in
107 the case of an error, -1.
108 It IS legal to intermix calls to bzread and bzreadline.
110 At this time bzreadline ignores the variable $/
112 ($INPUT_RECORD_SEPARATOR or $RS when "English" is in use). The end of a
113 line is denoted by the C character '\n'.
114 $byteswritten = $bz->bzwrite($buffer [, $limit]) ;
116 Writes the contents of $buffer to the compressed file. Returns the
117 number of bytes actually written, or 0 on error.
118 If $limit is given and non-zero, then only that many bytes from $buffer
120 will be written.
121 $status = $bz->bzflush($flush) ;
123 Flushes all pending output to the compressed file. Works identically
124 to the zlib function it interfaces to. Note that the use of bzflush can
125 degrade compression.
126 Returns "BZ_OK" if $flush is "BZ_FINISH" and all output could be
128 flushed. Otherwise the bzlib error code is returned.
129 Refer to the bzlib documentation for the valid values of $flush.
131 $status = $bz->bzeof() ;
133 Returns 1 if the end of file has been detected while reading the input
134 file, otherwise returns 0.
135 $bz->bzclose
137 Closes the compressed file. Any pending data is flushed to the file
138 before it is closed.
139 $bz->bzsetparams( [PARAMS] );
141 Change settings for the deflate stream $bz.
142 The list of the valid options is shown below. Options not specified
144 will remain unchanged.
145 -verbosity
147 Defines the verbosity level. Valid values are 0 through 4,
148 The default is "-verbosity => 0".
150 -blockSize100k
152 For bzip object opened for stream deflation or write.
153 Defines the buffering factor of compression method. The algorithm
155 buffers all data until the buffer is full, then it flushes all the
156 data out. Use -blockSize100k to specify the size of the buffer.
157 Valid settings are 1 through 9, representing a blocking in
159 multiples of 100k.
160 Note that each such block has an overhead of leading and trailing
162 synchronization bytes. bzip2 recovery uses this information to
163 pull useable data out of a corrupted file.
164 A streaming application would probably want to set the blocking
166 low.
167 -workFactor
169 For bzip object opened for stream deflation or write.
170 The workFactor setting tells the deflation algorithm how much work
172 to invest to compensate for repetitive data.
173 workFactor may be a number from 0 to 250 inclusive. The default
175 setting is 30.
176 See the bzip documentation for more information.
178 -small
180 For bzip object opened for stream inflation or read.
181 small may be 0 or 1. Set "small" to one to use a slower, less
183 memory intensive algorithm.
184 $bz->bzerror
186 Returns the bzlib error message or number for the last operation
187 associated with $bz. The return value will be the bzlib error number
188 when used in a numeric context and the bzlib error message when used in
189 a string context. The bzlib error number constants, shown below, are
190 available for use.
191 BZ_CONFIG_ERROR
193 BZ_DATA_ERROR
194 BZ_DATA_ERROR_MAGIC
195 BZ_FINISH
196 BZ_FINISH_OK
197 BZ_FLUSH
198 BZ_FLUSH_OK
199 BZ_IO_ERROR
200 BZ_MAX_UNUSED
201 BZ_MEM_ERROR
202 BZ_OK
203 BZ_OUTBUFF_FULL
204 BZ_PARAM_ERROR
205 BZ_RUN
206 BZ_RUN_OK
207 BZ_SEQUENCE_ERROR
208 BZ_STREAM_END
209 BZ_UNEXPECTED_EOF
210 $bz->bzclearerr
212 $bzerrno
213 The $bzerrno scalar holds the error code associated with the most
214 recent bzip2 routine. Note that unlike bzerror(), the error is not
215 associated with a particular file.
216 As with bzerror() it returns an error number in numeric context and an
218 error message in string context. Unlike bzerror() though, the error
219 message will correspond to the bzlib message when the error is
220 associated with bzlib itself, or the UNIX error message when it is not
221 (i.e. bzlib returned "Z_ERRORNO").
222 As there is an overlap between the error numbers used by bzlib and
224 UNIX, $bzerrno should only be used to check for the presence of an
225 error in numeric context. Use bzerror() to check for specific bzlib
226 errors. The bzcat example below shows how the variable can be used
227 safely.
228 $bz->prefix
230 Returns the additional 5 byte header which is prepended to the bzip2
231 header starting with "BZh" when using memBzip/compress.
232
234 Options: -d -c -z -f -v -k -s -1..9
235 bzip2( [OPTS], filename)
237 bunzip2(filename)
238 bzcat(filenames...)
239 bzlibversion()
240 bzinflateInit( opts... )
242 bz_seterror(errno, msg) =head2 $bz->is_read() =head2 $bz->is_stream()
243 =head2 $bz->is_write() =head2 $bz->total_in() =head2 $bz->total_out()
244 =head2 version()
246 While the 2.x thread forked off of 1.00, another line of development
247 came to a head at 1.03. The 1.03 version worked with bzlib 1.0.2, had
248 improvements to the error handling, single buffer inflate/deflate, a
249 streaming interface to inflate/deflate, and a cpan style test suite.
250 $dest = compress( $string, [$level] )
252 Alias to memBzip, this compresses string, using the optional
253 compression level, 1 through 9, the default being 6. Returns a string
254 containing the compressed data.
255 On error undef is returned.
257 $dest = decompress($string, [$level])
259 Alias to memBunzip, this decompresses the data in string, returning a
260 string containing the decompressed data.
261 On error undef is returned.
263 uncompress($string, [$level])
265 Another alias to memBunzip
266 $stream = compress_init( [PARAMS] )
268 Alias to bzdeflateInit. In addition to the named parameters documented
269 for bzdeflateInit, the following are accepted:
270 -level, alias to -blockSize100k
272 -buffer, to set the buffer size.
273 The -buffer option is ignored. The intermediate buffer size is not
275 changeable.
276 $stream = decompress_init( [PARAMS] )
278 Alias to bzinflateInit. See bzinflateInit for a description of the
279 parameters. The option "-buffer" is accepted, but ignored.
280 $output = $stream->add( $string )
282 Add data to be compressed/decompressed. Returns whatever output is
283 available (possibly none, if it's still buffering it), or undef on
284 error.
285 $output = $stream->finish( [$string] )
287 Finish the operation; takes an optional final data string. Whatever is
288 returned completes the output; returns undef on error.
289 $stream->error
291 Like the function, but applies to the current object only. Note that
292 errors in a stream object are also returned by the function.
293 $stream->input_size
295 Alias to total_in. Total bytes passed to the stream.
296 $stream->output_size
298 Alias to total_out. Total bytes received from the stream.
299
301 Except for the exact state and error numbers, this package presents an
302 interface very much like that given by the Compress::Zlib package.
303 Mostly, if you take the method name, state or error number from
304 Compress::Zlib and replace the "g" with a "b", your code should work.
305 To make the interoperability even easier, all the Compress::Zlib method
307 names have been used as aliases or cover functions for the bzip2
308 methods.
309 Therefore, most code that uses Compress::Zlib should be able to use
311 this package, with a one line change.
312 Simply change
314 $gz = Compress::Zlib::gzopen( "filename", "w" );
316 to
318 $gz = Compress::Bzip2::gzopen( "filename", "w" );
320 Some of the Compress::Zlib aliases don't return anything useful, like
322 crc32 or adler32, cause bzip2 doesn't do that sort of thing.
323 $gz = gzopen( $filename, $mode )
325 Alias for bzopen.
326 $gz->gzread( $buffer, [ $length ] )
328 Alias for bzread.
329 $gz->gzreadline( $buffer )
331 Alias for bzreadline.
332 $gz->gzwrite( $buffer )
334 Alias for bzwrite.
335 $gz->gzflush( [$flushtype] )
337 Alias for bzflush, with return code translation.
338 $gz->gzclose( )
340 Alias for bzclose.
341 $gz->gzeof( )
343 Alias for bzeof.
344 $gz->gzerror( )
346 Alias for bzerror.
347 $gz->gzsetparams( $level, $strategy )
349 This is a no-op.
350 $d = deflateInit( [OPTS] )
352 Alias for bzdeflateInit, with return code translation.
353 All OPTS are ignored.
355 $d->deflate( $buffer )
357 Alias for bzdeflate, with return code translation.
358 $d->deflateParams( [OPTS] )
360 This is a no-op.
361 $d->flush( [$flushtype] )
363 Cover function for bzflush or bzclose, depending on $flushtype.
364 See the Compress::Zlib documentation for more information.
366 $d->dict_adler( )
368 This is a no-op.
369 $d->msg( )
371 This is a no-op.
372 $d = inflateInit( [OPTS] )
374 Alias for bzinflateInit, with return code translation.
375 All OPTS are ignored.
377 $d->inflate( )
379 Alias for bzinflate, with return code translation.
380 $d->inflateSync( )
382 This is a no-op.
383 $d->adler32( $crc )
385 This is a no-op.
386 $d->crc32( $crc )
388 This is a no-op.
389 $buffer = memGzip( $buffer )
391 Alias for memBzip.
392 $buffer = memGunzip( $buffer )
394 Alias for memBunzip.
395
397 Two high-level functions are provided by bzlib to perform in-memory
398 compression. They are memBzip and memBunzip. Two Perl subs are provided
399 which provide similar functionality.
400 $compressed = memBzip($buffer);
402 Compresses $buffer. If successful it returns the compressed data.
403 Otherwise it returns undef.
404 The buffer parameter can either be a scalar or a scalar reference.
406 Essentially, an in-memory bzip file is created. It creates a minimal
408 bzip header, which adds 5 bytes before the bzip2 specific BZh header.
409 $uncompressed = memBunzip($buffer);
411 Uncompresses $buffer. If successful it returns the uncompressed data.
412 Otherwise it returns undef.
413 The source buffer can either be a scalar or a scalar reference.
415 The buffer parameter can either be a scalar or a scalar reference. The
417 contents of the buffer parameter are destroyed after calling this
418 function.
419
421 The Perl interface will always consume the complete input buffer before
422 returning. Also the output buffer returned will be automatically grown
423 to fit the amount of output available.
424 Here is a definition of the interface available:
426 ($d, $status) = bzdeflateInit( [PARAMS] )
428 Initialises a deflation stream.
429 If successful, it will return the initialised deflation stream, $d and
431 $status of "BZ_OK" in a list context. In scalar context it returns the
432 deflation stream, $d, only.
433 If not successful, the returned deflation stream ($d) will be undef and
435 $status will hold the exact bzip2 error code.
436 The function optionally takes a number of named options specified as
438 "-Name=>value" pairs. This allows individual options to be tailored
439 without having to specify them all in the parameter list.
440 Here is a list of the valid options:
442 -verbosity
444 Defines the verbosity level. Valid values are 0 through 4,
445 The default is "-verbosity => 0".
447 -blockSize100k
449 Defines the buffering factor of compression method. The algorithm
450 buffers all data until the buffer is full, then it flushes all the
451 data out. Use -blockSize100k to specify the size of the buffer.
452 Valid settings are 1 through 9, representing a blocking in
454 multiples of 100k.
455 Note that each such block has an overhead of leading and trailing
457 synchronization bytes. bzip2 recovery uses this information to
458 pull useable data out of a corrupted file.
459 A streaming application would probably want to set the blocking
461 low.
462 -workFactor
464 The workFactor setting tells the deflation algorithm how much work
465 to invest to compensate for repetitive data.
466 workFactor may be a number from 0 to 250 inclusive. The default
468 setting is 30.
469 See the bzip documentation for more information.
471 Here is an example of using the deflateInit optional parameter list to
473 override the default buffer size and compression level. All other
474 options will take their default values.
475 bzdeflateInit( -blockSize100k => 1, -verbosity => 1 );
477 ($out, $status) = $d->bzdeflate($buffer)
479 Deflates the contents of $buffer. The buffer can either be a scalar or
480 a scalar reference. When finished, $buffer will be completely
481 processed (assuming there were no errors). If the deflation was
482 successful it returns deflated output, $out, and a status value,
483 $status, of "Z_OK".
484 On error, $out will be undef and $status will contain the zlib error
486 code.
487 In a scalar context bzdeflate will return $out only.
489 As with the internal buffering of the deflate function in bzip2, it is
491 not necessarily the case that any output will be produced by this
492 method. So don't rely on the fact that $out is empty for an error test.
493 In fact, given the size of bzdeflates internal buffer, with most files
494 it's likely you won't see any output at all until flush or close.
495 ($out, $status) = $d->bzflush([flush_type])
497 Typically used to finish the deflation. Any pending output will be
498 returned via $out. $status will have a value "BZ_OK" if successful.
499 In a scalar context bzflush will return $out only.
501 Note that flushing can seriously degrade the compression ratio, so it
503 should only be used to terminate a decompression (using "BZ_FLUSH") or
504 when you want to create a full flush point (using "BZ_FINISH").
505 The allowable values for "flush_type" are "BZ_FLUSH" and "BZ_FINISH".
507 For a handle opened for "w" (bzwrite), the default is "BZ_FLUSH". For
509 a stream, the default for "flush_type" is "BZ_FINISH" (which is
510 essentially a close and reopen).
511 It is strongly recommended that you only set the "flush_type" parameter
513 if you fully understand the implications of what it does. See the
514 "bzip2" documentation for details.
515 Example
517 Here is a trivial example of using bzdeflate. It simply reads standard
518 input, deflates it and writes it to standard output.
519 use strict ;
521 use warnings ;
522 use Compress::Bzip2 ;
524 binmode STDIN;
526 binmode STDOUT;
527 my $x = bzdeflateInit()
528 or die "Cannot create a deflation stream\n" ;
529 my ($output, $status) ;
531 while (<>)
532 {
533 ($output, $status) = $x->bzdeflate($_) ;
534 $status == BZ_OK
536 or die "deflation failed\n" ;
537 print $output ;
539 }
540 ($output, $status) = $x->bzclose() ;
542 $status == BZ_OK
544 or die "deflation failed\n" ;
545 print $output ;
547
549 Here is a definition of the interface:
550 ($i, $status) = inflateInit()
552 Initialises an inflation stream.
553 In a list context it returns the inflation stream, $i, and the zlib
555 status code ($status). In a scalar context it returns the inflation
556 stream only.
557 If successful, $i will hold the inflation stream and $status will be
559 "BZ_OK".
560 If not successful, $i will be undef and $status will hold the bzlib.h
562 error code.
563 The function optionally takes a number of named options specified as
565 "-Name=>value" pairs. This allows individual options to be tailored
566 without having to specify them all in the parameter list.
567 For backward compatibility, it is also possible to pass the parameters
569 as a reference to a hash containing the name=>value pairs.
570 The function takes one optional parameter, a reference to a hash. The
572 contents of the hash allow the deflation interface to be tailored.
573 Here is a list of the valid options:
575 -small
577 small may be 0 or 1. Set "small" to one to use a slower, less
578 memory intensive algorithm.
579 -verbosity
581 Defines the verbosity level. Valid values are 0 through 4,
582 The default is "-verbosity => 0".
584 Here is an example of using the bzinflateInit optional parameter.
586 bzinflateInit( -small => 1, -verbosity => 1 );
588 ($out, $status) = $i->bzinflate($buffer)
590 Inflates the complete contents of $buffer. The buffer can either be a
591 scalar or a scalar reference.
592 Returns "BZ_OK" if successful and "BZ_STREAM_END" if the end of the
594 compressed data has been successfully reached. If not successful, $out
595 will be undef and $status will hold the bzlib error code.
596 The $buffer parameter is modified by "bzinflate". On completion it will
598 contain what remains of the input buffer after inflation. This means
599 that $buffer will be an empty string when the return status is "BZ_OK".
600 When the return status is "BZ_STREAM_END" the $buffer parameter will
601 contains what (if anything) was stored in the input buffer after the
602 deflated data stream.
603 This feature is useful when processing a file format that encapsulates
605 a compressed data stream.
606 Example
608 Here is an example of using bzinflate.
609 use strict ;
611 use warnings ;
612 use Compress::Bzip2;
614 my $x = bzinflateInit()
616 or die "Cannot create a inflation stream\n" ;
617 my $input = '' ;
619 binmode STDIN;
620 binmode STDOUT;
621 my ($output, $status) ;
623 while (read(STDIN, $input, 4096))
624 {
625 ($output, $status) = $x->bzinflate(\$input) ;
626 print $output
628 if $status == BZ_OK or $status == BZ_STREAM_END ;
629 last if $status != BZ_OK ;
631 }
632 die "inflation failed\n"
634 unless $status == BZ_STREAM_END ;
635
637 Here are some example scripts of using the interface.
638 A bzcat function
640 use strict ;
641 use warnings ;
642 use Compress::Bzip2 ;
644 die "Usage: bzcat file...\n" unless @ARGV ;
646 my $file ;
648 foreach $file (@ARGV) {
650 my $buffer ;
651 my $bz = bzopen($file, "rb")
653 or die "Cannot open $file: $bzerrno\n" ;
654 print $buffer while $bz->bzread($buffer) > 0 ;
656 die "Error reading from $file: $bzerrno" . ($bzerrno+0) . "\n"
658 if $bzerrno != BZ_STREAM_END ;
659 $bz->bzclose() ;
661 }
662 A grep using bzreadline
664 use strict ;
665 use warnings ;
666 use Compress::Bzip2 ;
668 die "Usage: bzgrep pattern file...\n" unless @ARGV >= 2;
670 my $pattern = shift ;
672 my $file ;
674 foreach $file (@ARGV) {
676 my $bz = bzopen($file, "rb")
677 or die "Cannot open $file: $bzerrno\n" ;
678 while ($bz->bzreadline($_) > 0) {
680 print if /$pattern/ ;
681 }
682 die "Error reading from $file: $bzerrno\n"
684 if $bzerrno != Z_STREAM_END ;
685 $bz->bzclose() ;
687 }
688 Streaming Compression
690 This script, bzstream, does the opposite of the bzcat script above. It
691 reads from standard input and writes a bzip file to standard output.
692 use strict ;
694 use warnings ;
695 use Compress::Bzip2 ;
697 binmode STDOUT; # bzopen only sets it on the fd
699 my $bz = bzopen(\*STDOUT, "wb")
701 or die "Cannot open stdout: $bzerrno\n" ;
702 while (<>) {
704 $bz->bzwrite($_) or die "error writing: $bzerrno\n" ;
705 }
706 $bz->bzclose ;
708
710 Use the tags :all, :utilities, :constants, :bzip1 and :gzip.
711 Export tag :all
713 This exports all the exportable methods.
714 Export tag :constants
716 This exports only the BZ_* constants.
717 Export tag :bzip1
719 This exports the Compress::Bzip2 1.x functions, for compatibility.
720 compress
722 decompress
723 compress_init
724 decompress_init
725 version
726 These are actually aliases to memBzip and memBunzip.
728 Export tag :utilities
730 This gives an interface to the bzip2 methods.
731 bzopen
733 bzinflateInit
734 bzdeflateInit
735 memBzip
736 memBunzip
737 bzip2
738 bunzip2
739 bzcat
740 bzlibversion
741 $bzerrno
742 Export tag :gzip
744 This gives compatibility with Compress::Zlib.
745 gzopen
747 gzinflateInit
748 gzdeflateInit
749 memGzip
750 memGunzip
751 $gzerrno
752
754 All the bzlib constants are automatically imported when you make use of
755 Compress::Bzip2.
756 BZ_CONFIG_ERROR
758 BZ_DATA_ERROR
759 BZ_DATA_ERROR_MAGIC
760 BZ_FINISH
761 BZ_FINISH_OK
762 BZ_FLUSH
763 BZ_FLUSH_OK
764 BZ_IO_ERROR
765 BZ_MAX_UNUSED
766 BZ_MEM_ERROR
767 BZ_OK
768 BZ_OUTBUFF_FULL
769 BZ_PARAM_ERROR
770 BZ_RUN
771 BZ_RUN_OK
772 BZ_SEQUENCE_ERROR
773 BZ_STREAM_END
774 BZ_UNEXPECTED_EOF
775
777 The documentation for zlib, bzip2 and Compress::Zlib.
778
780 Rob Janes, <arjay at cpan.org>
781
783 Copyright (C) 2005 by Rob Janes
784 This library is free software; you can redistribute it and/or modify it
786 under the same terms as Perl itself, either Perl version 5.8.3 or, at
787 your option, any later version of Perl 5 you may have available.
788
790 The Compress::Bzip2 module was originally written by Gawdi Azem
791 azemgi@rupert.informatik.uni-stuttgart.de.
792 The first Compress::Bzip2 module was written by Gawdi Azem
794 azemgi@rupert.informatik.uni-stuttgart.de. It provided an interface to
795 the in memory inflate and deflate routines.
796 Compress::Bzip2 was subsequently passed on to Marco Carnut
798 kiko@tempest.com.br who shepherded it through to version 1.03, a set of
799 changes which included upgrades to handle bzlib 1.0.2, and improvements
800 to the in memory inflate and deflate routines. The streaming interface
801 and error information were added by David Robins
802 dbrobins@davidrobins.net.
803 Version 2 of Compress::Bzip2 is due to Rob Janes, of arjay@cpan.org.
805 This release is intended to give an interface close to that of
806 Compress::Zlib. It's development forks from 1.00, not 1.03, so the
807 streaming interface is not the same as that in 1.03, although
808 apparently compatible as it passes the 1.03 test suite.
809 Minor subsequent fixes and releases were done by Reini Urban,
811 rurban@cpan.org.
812
814 See the Changes file.
815 2.00 Second public release of Compress::Bzip2.
817perl v5.26.3 2017-04-10 Compress::Bzip2(3)